ncurses 6.1 - patch 20180303
[ncurses.git] / test / cardfile.c
index bc2e1adb14cc68158f3d01690b0b7e0597a14e00..ba9e8de53bae1f8b2eff2c0485247f9dc849e37c 100644 (file)
@@ -1,5 +1,5 @@
 /****************************************************************************
- * Copyright (c) 1999 Free Software Foundation, Inc.                        *
+ * Copyright (c) 1999-2016,2017 Free Software Foundation, Inc.              *
  *                                                                          *
  * Permission is hereby granted, free of charge, to any person obtaining a  *
  * copy of this software and associated documentation files (the            *
  ****************************************************************************/
 
 /*
- * Author: Thomas E. Dickey <dickey@clark.net> 1999
+ * Author: Thomas E. Dickey
  *
- * $Id: cardfile.c,v 1.2 1999/06/16 00:41:57 tom Exp $
+ * $Id: cardfile.c,v 1.45 2017/10/19 21:14:25 tom Exp $
  *
- * File format: text beginning in column 1 is a title; other text forms the content.
+ * File format: text beginning in column 1 is a title; other text is content.
  */
 
 #include <test.priv.h>
 
+#if USE_LIBFORM && USE_LIBPANEL
+
 #include <form.h>
 #include <panel.h>
 
-#include <string.h>
-#include <ctype.h>
-
 #define VISIBLE_CARDS 10
 #define OFFSET_CARD 2
+#define pair_1 1
+#define pair_2 2
 
-#ifndef CTRL
-#define CTRL(x)                ((x) & 0x1f)
-#endif
+#define isVisible(cardp) ((cardp)->panel != 0)
+
+enum {
+    MY_CTRL_x = MAX_FORM_COMMAND
+    ,MY_CTRL_N
+    ,MY_CTRL_P
+    ,MY_CTRL_Q
+    ,MY_CTRL_W
+};
 
 typedef struct _card {
-       struct _card *link;
-       PANEL *panel;
-       FORM *form;
-       char *title;
-       char *content;
+    struct _card *link;
+    PANEL *panel;
+    FORM *form;
+    char *title;
+    char *content;
 } CARD;
 
 static CARD *all_cards;
+static bool try_color = FALSE;
 static char default_name[] = "cardfile.dat";
 
-#if !HAVE_STRDUP
-#define strdup my_strdup
-static char *strdup (char *s)
+static void
+failed(const char *s)
 {
-    char *p = (char *)malloc(strlen(s)+1);
-    if (p)
-       strcpy(p, s);
-    return(p);
+    perror(s);
+    endwin();
+    ExitProgram(EXIT_FAILURE);
 }
-#endif /* not HAVE_STRDUP */
 
-static char *skip(char *buffer)
+static const char *
+skip(const char *buffer)
 {
-    while (isspace(*buffer))
+    while (isspace(UChar(*buffer)))
        buffer++;
     return buffer;
 }
 
-static void trim(char *buffer)
+static void
+trim(char *buffer)
 {
-    unsigned n = strlen(buffer);
-    while (n-- && isspace(buffer[n]))
-       buffer[n] = 0;
+    size_t n = strlen(buffer);
+    while (n-- && isspace(UChar(buffer[n])))
+       buffer[n] = 0;
 }
 
 /*******************************************************************************/
 
-static CARD *add_title(const char *title)
+static CARD *
+add_title(const char *title)
 {
     CARD *card, *p, *q;
 
-    for (p = all_cards, q = 0; p != 0; q = p, p = p->link)
-    {
+    for (p = all_cards, q = 0; p != 0; q = p, p = p->link) {
        int cmp = strcmp(p->title, title);
        if (cmp == 0)
            return p;
@@ -100,46 +107,58 @@ static CARD *add_title(const char *title)
            break;
     }
 
-    card = (CARD *)calloc(1, sizeof(CARD));
+    card = typeCalloc(CARD, (size_t) 1);
     card->title = strdup(title);
     card->content = strdup("");
 
-    if (q == 0)
-    {
+    if (q == 0) {
        card->link = all_cards;
        all_cards = card;
-    }
-    else
-    {
-       card->link = q->link;
+    } else {
+       card->link = q->link;
        q->link = card;
     }
 
     return card;
 }
 
-static void add_content(CARD *card, char *content)
+static void
+add_content(CARD * card, const char *content)
 {
-    unsigned total, offset;
+    size_t total, offset;
 
     content = skip(content);
-    if ((total = strlen(content)) != 0)
-    {
-       if ((offset = strlen(card->content)) != 0)
-       {
+    if ((total = strlen(content)) != 0) {
+       if (card->content != 0 && (offset = strlen(card->content)) != 0) {
            total += 1 + offset;
-           card->content = (char *)realloc(card->content, total + 1);
-           strcpy(card->content + offset++, " ");
+           card->content = typeRealloc(char, total + 1, card->content);
+           if (card->content) {
+               _nc_STRCPY(card->content + offset, " ", total + 1 - offset);
+               offset++;
+           }
+       } else {
+           offset = 0;
+           if (card->content != 0)
+               free(card->content);
+           card->content = typeMalloc(char, total + 1);
        }
+       if (card->content)
+           _nc_STRCPY(card->content + offset, content, total + 1 - offset);
        else
-       {
-           card->content = (char *)malloc(total + 1);
-       }
-       strcpy(card->content + offset, content);
+           failed("add_content");
     }
 }
 
-static CARD *find_card(char *title)
+static CARD *
+new_card(void)
+{
+    CARD *card = add_title("");
+    add_content(card, "");
+    return card;
+}
+
+static CARD *
+find_card(char *title)
 {
     CARD *card;
 
@@ -150,25 +169,21 @@ static CARD *find_card(char *title)
     return card;
 }
 
-static void read_data(char *fname)
+static void
+read_data(char *fname)
 {
     FILE *fp;
     CARD *card = 0;
     char buffer[BUFSIZ];
 
-    if ((fp = fopen(fname, "r")) != 0)
-    {
-       while (fgets(buffer, sizeof(buffer), fp))
-       {
+    if ((fp = fopen(fname, "r")) != 0) {
+       while (fgets(buffer, sizeof(buffer), fp)) {
            trim(buffer);
-           if (isspace(*buffer))
-           {
+           if (isspace(UChar(*buffer))) {
                if (card == 0)
                    card = add_title("");
                add_content(card, buffer);
-           }
-           else if ((card = find_card(buffer)) == 0)
-           {
+           } else if ((card = find_card(buffer)) == 0) {
                card = add_title(buffer);
            }
        }
@@ -178,7 +193,8 @@ static void read_data(char *fname)
 
 /*******************************************************************************/
 
-static void write_data(const char *fname)
+static void
+write_data(const char *fname)
 {
     FILE *fp;
     CARD *p = 0;
@@ -187,17 +203,13 @@ static void write_data(const char *fname)
     if (!strcmp(fname, default_name))
        fname = "cardfile.out";
 
-    if ((fp = fopen(fname, "w")) != 0)
-    {
-       for (p = all_cards; p != 0; p = p->link)
-       {
+    if ((fp = fopen(fname, "w")) != 0) {
+       for (p = all_cards; p != 0; p = p->link) {
            FIELD **f = form_fields(p->form);
-           for (n = 0; f[n] != 0; n++)
-           {
+           for (n = 0; f[n] != 0; n++) {
                char *s = field_buffer(f[n], 0);
                if (s != 0
-                && (s = strdup(s)) != 0)
-               {
+                   && (s = strdup(s)) != 0) {
                    trim(s);
                    fprintf(fp, "%s%s\n", n ? "\t" : "", s);
                    free(s);
@@ -213,7 +225,8 @@ static void write_data(const char *fname)
 /*
  * Count the cards
  */
-static int count_cards(void)
+static int
+count_cards(void)
 {
     CARD *p;
     int count = 0;
@@ -227,159 +240,276 @@ static int count_cards(void)
 /*
  * Shuffle the panels to keep them in a natural hierarchy.
  */
-static void order_cards(CARD *first, int depth)
+static void
+order_cards(CARD * first, int depth)
 {
-    if (first)
-    {
+    if (first) {
        if (depth && first->link)
-           order_cards(first->link, depth-1);
-       top_panel(first->panel);
+           order_cards(first->link, depth - 1);
+       if (isVisible(first))
+           top_panel(first->panel);
     }
 }
 
 /*
  * Return the next card in the list
  */
-static CARD *next_card(CARD *now)
+static CARD *
+next_card(CARD * now)
 {
-    if (now->link)
-       now = now->link;
+    if (now->link != 0) {
+       CARD *tst = now->link;
+       if (isVisible(tst))
+           now = tst;
+       else
+           (void) next_card(tst);
+    }
     return now;
 }
 
 /*
  * Return the previous card in the list
  */
-static CARD *prev_card(CARD *now)
+static CARD *
+prev_card(CARD * now)
 {
     CARD *p;
-    for (p = all_cards; p != 0; p = p->link)
-       if (p->link == now)
+    for (p = all_cards; p != 0; p = p->link) {
+       if (p->link == now) {
+           if (!isVisible(p))
+               p = prev_card(p);
            return p;
+       }
+    }
     return now;
 }
 
+/*
+ * Returns the first card in the list that we will display.
+ */
+static CARD *
+first_card(CARD * now)
+{
+    if (!isVisible(now))
+       now = next_card(now);
+    return now;
+}
 
 /*******************************************************************************/
 
-static int form_virtualize(WINDOW *w)
+static int
+form_virtualize(WINDOW *w)
 {
-    int                c = wgetch(w);
+    int c = wgetch(w);
 
-    switch(c)
-    {
+    switch (c) {
     case CTRL('W'):
-       return(MAX_FORM_COMMAND + 4);
+       return (MY_CTRL_W);
     case CTRL('N'):
-       return(MAX_FORM_COMMAND + 3);
+       return (MY_CTRL_N);
     case CTRL('P'):
-       return(MAX_FORM_COMMAND + 2);
-    case CTRL('Q'):
-    case 033:
-       return(MAX_FORM_COMMAND + 1);
+       return (MY_CTRL_P);
+    case QUIT:
+    case ESCAPE:
+       return (MY_CTRL_Q);
 
     case KEY_BACKSPACE:
-       return(REQ_DEL_PREV);
+       return (REQ_DEL_PREV);
     case KEY_DC:
-       return(REQ_DEL_CHAR);
+       return (REQ_DEL_CHAR);
     case KEY_LEFT:
-       return(REQ_LEFT_CHAR);
+       return (REQ_LEFT_CHAR);
     case KEY_RIGHT:
-       return(REQ_RIGHT_CHAR);
+       return (REQ_RIGHT_CHAR);
 
     case KEY_DOWN:
     case KEY_NEXT:
-       return(REQ_NEXT_FIELD);
+       return (REQ_NEXT_FIELD);
     case KEY_UP:
     case KEY_PREVIOUS:
-       return(REQ_PREV_FIELD);
+       return (REQ_PREV_FIELD);
 
     default:
-       return(c);
+       return (c);
+    }
+}
+
+static FIELD **
+make_fields(CARD * p, int form_high, int form_wide)
+{
+    FIELD **f = typeCalloc(FIELD *, (size_t) 3);
+
+    f[0] = new_field(1, form_wide, 0, 0, 0, 0);
+    set_field_back(f[0], A_REVERSE);
+    set_field_buffer(f[0], 0, p->title);
+    field_opts_off(f[0], O_BLANK);
+
+    f[1] = new_field(form_high - 1, form_wide, 1, 0, 0, 0);
+    set_field_buffer(f[1], 0, p->content);
+    set_field_just(f[1], JUSTIFY_LEFT);
+    field_opts_off(f[1], O_BLANK);
+
+    f[2] = 0;
+    return f;
+}
+
+static void
+show_legend(void)
+{
+    erase();
+    move(LINES - 3, 0);
+    addstr("^Q/ESC -- exit form            ^W   -- writes data to file\n");
+    addstr("^N   -- go to next card        ^P   -- go to previous card\n");
+    addstr("Arrow keys move left/right within a field, up/down between fields");
+}
+
+#if (defined(KEY_RESIZE) && HAVE_WRESIZE) || NO_LEAKS
+static void
+free_form_fields(FIELD ** f)
+{
+    int n;
+
+    for (n = 0; f[n] != 0; ++n) {
+       free_field(f[n]);
     }
+    free(f);
 }
+#endif
 
 /*******************************************************************************/
 
-static void cardfile(char *fname)
+static void
+cardfile(char *fname)
 {
     WINDOW *win;
     CARD *p;
     CARD *top_card;
-    int visible_cards = count_cards();
-    int panel_wide = COLS - (visible_cards * OFFSET_CARD);
-    int panel_high = LINES - (visible_cards * OFFSET_CARD) - 5;
-    int form_wide = panel_wide - 2;
-    int form_high = panel_high - 2;
-    int x = (visible_cards - 1) * OFFSET_CARD;
-    int y = 0;
-    int ch;
+    int visible_cards;
+    int panel_wide;
+    int panel_high;
+    int form_wide;
+    int form_high;
+    int y;
+    int x;
+    int ch = ERR;
     int finished = FALSE;
 
-    move(LINES - 3, 0);
-    addstr("^Q/ESC -- exit form            ^W   -- writes data to file\n");
-    addstr("^N   -- go to next card        ^P   -- go to previous card\n");
-    addstr("Arrow keys move left/right within a field, up/down between fields");
+    show_legend();
+
+    /* decide how many cards we can display */
+    visible_cards = count_cards();
+    while (
+             (panel_wide = COLS - (visible_cards * OFFSET_CARD)) < 10 ||
+             (panel_high = LINES - (visible_cards * OFFSET_CARD) - 5) < 5) {
+       --visible_cards;
+    }
+    form_wide = panel_wide - 2;
+    form_high = panel_high - 2;
+    y = (visible_cards - 1) * OFFSET_CARD;
+    x = 0;
 
     /* make a panel for each CARD */
-    for (p = all_cards; p != 0; p = p->link)
-    {
-       FIELD **f = (FIELD **)calloc(3, sizeof(FIELD *));
+    for (p = all_cards; p != 0; p = p->link) {
+
+       if ((win = newwin(panel_high, panel_wide, y, x)) == 0)
+           break;
 
-       win = newwin(panel_high, panel_wide, x, y);
+       wbkgd(win, (chtype) COLOR_PAIR(pair_2));
        keypad(win, TRUE);
        p->panel = new_panel(win);
        box(win, 0, 0);
 
-       /* ...and a form in each panel */
-       f[0] = new_field(1, form_wide, 0, 0, 0, 0);
-       set_field_back(f[0], A_REVERSE);
-       set_field_buffer(f[0], 0, p->title);
-
-       f[1] = new_field(form_high-1, form_wide, 1, 0, 0, 0);
-       set_field_buffer(f[1], 0, p->content);
-       set_field_just(f[1], JUSTIFY_LEFT);
-
-       f[2] = 0;
-
-       p->form = new_form(f);
+       p->form = new_form(make_fields(p, form_high, form_wide));
        set_form_win(p->form, win);
        set_form_sub(p->form, derwin(win, form_high, form_wide, 1, 1));
        post_form(p->form);
 
-       x -= OFFSET_CARD;
-       y += OFFSET_CARD;
+       y -= OFFSET_CARD;
+       x += OFFSET_CARD;
     }
 
-    order_cards(top_card = all_cards, visible_cards);
-
-    update_panels();
+    top_card = first_card(all_cards);
+    order_cards(top_card, visible_cards);
 
-    while (!finished)
-    {
+    while (!finished) {
        update_panels();
        doupdate();
 
-       switch(form_driver(top_card->form, ch = form_virtualize(panel_window(top_card->panel))))
-       {
+       ch = form_virtualize(panel_window(top_card->panel));
+       switch (form_driver(top_card->form, ch)) {
        case E_OK:
            break;
        case E_UNKNOWN_COMMAND:
            switch (ch) {
-           case MAX_FORM_COMMAND+1:
+           case MY_CTRL_Q:
                finished = TRUE;
                break;
-           case MAX_FORM_COMMAND+2:
+           case MY_CTRL_P:
                top_card = prev_card(top_card);
                order_cards(top_card, visible_cards);
                break;
-           case MAX_FORM_COMMAND+3:
+           case MY_CTRL_N:
                top_card = next_card(top_card);
                order_cards(top_card, visible_cards);
                break;
-           case MAX_FORM_COMMAND+4:
+           case MY_CTRL_W:
+               form_driver(top_card->form, REQ_VALIDATION);
                write_data(fname);
                break;
+#if defined(KEY_RESIZE) && HAVE_WRESIZE
+           case KEY_RESIZE:
+               /* resizeterm already did "something" reasonable, but it cannot
+                * know much about layout.  So let's make it nicer.
+                */
+               panel_wide = COLS - (visible_cards * OFFSET_CARD);
+               panel_high = LINES - (visible_cards * OFFSET_CARD) - 5;
+
+               form_wide = panel_wide - 2;
+               form_high = panel_high - 2;
+
+               y = (visible_cards - 1) * OFFSET_CARD;
+               x = 0;
+
+               show_legend();
+               for (p = all_cards; p != 0; p = p->link) {
+                   FIELD **oldf = form_fields(p->form);
+                   WINDOW *olds = form_sub(p->form);
+
+                   if (!isVisible(p))
+                       continue;
+                   win = form_win(p->form);
+
+                   /* move and resize the card as needed
+                    * FIXME: if the windows are shrunk too much, this won't do
+                    */
+                   mvwin(win, y, x);
+                   wresize(win, panel_high, panel_wide);
+
+                   /* reconstruct each form.  Forms are not resizable, and
+                    * there appears to be no good way to reload the text in
+                    * a resized window.
+                    */
+                   werase(win);
+
+                   unpost_form(p->form);
+                   free_form(p->form);
+
+                   p->form = new_form(make_fields(p, form_high, form_wide));
+                   set_form_win(p->form, win);
+                   set_form_sub(p->form, derwin(win, form_high, form_wide,
+                                                1, 1));
+                   post_form(p->form);
+
+                   free_form_fields(oldf);
+                   delwin(olds);
+
+                   box(win, 0, 0);
+
+                   y -= OFFSET_CARD;
+                   x += OFFSET_CARD;
+               }
+               break;
+#endif
            default:
                beep();
                break;
@@ -390,31 +520,102 @@ static void cardfile(char *fname)
            break;
        }
     }
+#if NO_LEAKS
+    while (all_cards != 0) {
+       FIELD **f;
+
+       p = all_cards;
+       all_cards = all_cards->link;
+
+       if (isVisible(p)) {
+           f = form_fields(p->form);
+
+           unpost_form(p->form);       /* ...so we can free it */
+           free_form(p->form); /* this also disconnects the fields */
+
+           free_form_fields(f);
+
+           del_panel(p->panel);
+       }
+       free(p->title);
+       free(p->content);
+       free(p);
+    }
+#endif
+}
+
+static void
+usage(void)
+{
+    static const char *msg[] =
+    {
+       "Usage: cardfile [options] file"
+       ,""
+       ,"Options:"
+       ," -c       use color if terminal supports it"
+    };
+    size_t n;
+    for (n = 0; n < SIZEOF(msg); n++)
+       fprintf(stderr, "%s\n", msg[n]);
+    ExitProgram(EXIT_FAILURE);
 }
 
 /*******************************************************************************/
 
-int main(int argc, char *argv[])
+int
+main(int argc, char *argv[])
 {
     int n;
 
+    setlocale(LC_ALL, "");
+
+    while ((n = getopt(argc, argv, "c")) != -1) {
+       switch (n) {
+       case 'c':
+           try_color = TRUE;
+           break;
+       default:
+           usage();
+       }
+    }
+
     initscr();
     cbreak();
     noecho();
 
-    if (argc > 1)
-    {
+    if (try_color) {
+       if (has_colors()) {
+           start_color();
+           init_pair(pair_1, COLOR_WHITE, COLOR_BLUE);
+           init_pair(pair_2, COLOR_WHITE, COLOR_CYAN);
+           bkgd((chtype) COLOR_PAIR(pair_1));
+       } else {
+           try_color = FALSE;
+       }
+    }
+
+    if (optind + 1 == argc) {
        for (n = 1; n < argc; n++)
            read_data(argv[n]);
+       if (count_cards() == 0)
+           new_card();
        cardfile(argv[1]);
-    }
-    else
-    {
+    } else {
        read_data(default_name);
+       if (count_cards() == 0)
+           new_card();
        cardfile(default_name);
     }
 
     endwin();
 
-    return EXIT_SUCCESS;
+    ExitProgram(EXIT_SUCCESS);
 }
+#else
+int
+main(void)
+{
+    printf("This program requires the curses form and panel libraries\n");
+    ExitProgram(EXIT_FAILURE);
+}
+#endif