ncurses 5.3
[ncurses.git] / test / cardfile.c
1 /****************************************************************************
2  * Copyright (c) 1999-2001,2002 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 <dickey@clark.net> 1999
31  *
32  * $Id: cardfile.c,v 1.19 2002/09/01 17:59:48 tom Exp $
33  *
34  * File format: text beginning in column 1 is a title; other text forms the content.
35  */
36
37 #include <test.priv.h>
38
39 #if HAVE_FORM_H && HAVE_PANEL_H && HAVE_LIBFORM && HAVE_LIBPANEL
40
41 #include <form.h>
42 #include <panel.h>
43
44 #include <ctype.h>
45
46 #define VISIBLE_CARDS 10
47 #define OFFSET_CARD 2
48
49 #ifndef CTRL
50 #define CTRL(x)         ((x) & 0x1f)
51 #endif
52
53 typedef struct _card {
54     struct _card *link;
55     PANEL *panel;
56     FORM *form;
57     char *title;
58     char *content;
59 } CARD;
60
61 static CARD *all_cards;
62 static char default_name[] = "cardfile.dat";
63
64 #if !HAVE_STRDUP
65 #define strdup my_strdup
66 static char *
67 strdup(char *s)
68 {
69     char *p = (char *) malloc(strlen(s) + 1);
70     if (p)
71         strcpy(p, s);
72     return (p);
73 }
74 #endif /* not HAVE_STRDUP */
75
76 static const char *
77 skip(const char *buffer)
78 {
79     while (isspace(UChar(*buffer)))
80         buffer++;
81     return buffer;
82 }
83
84 static void
85 trim(char *buffer)
86 {
87     unsigned n = strlen(buffer);
88     while (n-- && isspace(UChar(buffer[n])))
89         buffer[n] = 0;
90 }
91
92 /*******************************************************************************/
93
94 static CARD *
95 add_title(const char *title)
96 {
97     CARD *card, *p, *q;
98
99     for (p = all_cards, q = 0; p != 0; q = p, p = p->link) {
100         int cmp = strcmp(p->title, title);
101         if (cmp == 0)
102             return p;
103         if (cmp > 0)
104             break;
105     }
106
107     card = (CARD *) calloc(1, sizeof(CARD));
108     card->title = strdup(title);
109     card->content = strdup("");
110
111     if (q == 0) {
112         card->link = all_cards;
113         all_cards = card;
114     } else {
115         card->link = q->link;
116         q->link = card;
117     }
118
119     return card;
120 }
121
122 static void
123 add_content(CARD * card, const char *content)
124 {
125     unsigned total, offset;
126
127     content = skip(content);
128     if ((total = strlen(content)) != 0) {
129         if ((offset = strlen(card->content)) != 0) {
130             total += 1 + offset;
131             card->content = (char *) realloc(card->content, total + 1);
132             strcpy(card->content + offset++, " ");
133         } else {
134             if (card->content != 0)
135                 free(card->content);
136             card->content = (char *) malloc(total + 1);
137         }
138         strcpy(card->content + offset, content);
139     }
140 }
141
142 static CARD *
143 new_card(void)
144 {
145     CARD *card = add_title("");
146     add_content(card, "");
147     return card;
148 }
149
150 static CARD *
151 find_card(char *title)
152 {
153     CARD *card;
154
155     for (card = all_cards; card != 0; card = card->link)
156         if (!strcmp(card->title, title))
157             break;
158
159     return card;
160 }
161
162 static void
163 read_data(char *fname)
164 {
165     FILE *fp;
166     CARD *card = 0;
167     char buffer[BUFSIZ];
168
169     if ((fp = fopen(fname, "r")) != 0) {
170         while (fgets(buffer, sizeof(buffer), fp)) {
171             trim(buffer);
172             if (isspace(UChar(*buffer))) {
173                 if (card == 0)
174                     card = add_title("");
175                 add_content(card, buffer);
176             } else if ((card = find_card(buffer)) == 0) {
177                 card = add_title(buffer);
178             }
179         }
180         fclose(fp);
181     }
182 }
183
184 /*******************************************************************************/
185
186 static void
187 write_data(const char *fname)
188 {
189     FILE *fp;
190     CARD *p = 0;
191     int n;
192
193     if (!strcmp(fname, default_name))
194         fname = "cardfile.out";
195
196     if ((fp = fopen(fname, "w")) != 0) {
197         for (p = all_cards; p != 0; p = p->link) {
198             FIELD **f = form_fields(p->form);
199             for (n = 0; f[n] != 0; n++) {
200                 char *s = field_buffer(f[n], 0);
201                 if (s != 0
202                     && (s = strdup(s)) != 0) {
203                     trim(s);
204                     fprintf(fp, "%s%s\n", n ? "\t" : "", s);
205                     free(s);
206                 }
207             }
208         }
209         fclose(fp);
210     }
211 }
212
213 /*******************************************************************************/
214
215 /*
216  * Count the cards
217  */
218 static int
219 count_cards(void)
220 {
221     CARD *p;
222     int count = 0;
223
224     for (p = all_cards; p != 0; p = p->link)
225         count++;
226
227     return count;
228 }
229
230 /*
231  * Shuffle the panels to keep them in a natural hierarchy.
232  */
233 static void
234 order_cards(CARD * first, int depth)
235 {
236     if (first) {
237         if (depth && first->link)
238             order_cards(first->link, depth - 1);
239         top_panel(first->panel);
240     }
241 }
242
243 /*
244  * Return the next card in the list
245  */
246 static CARD *
247 next_card(CARD * now)
248 {
249     if (now->link)
250         now = now->link;
251     return now;
252 }
253
254 /*
255  * Return the previous card in the list
256  */
257 static CARD *
258 prev_card(CARD * now)
259 {
260     CARD *p;
261     for (p = all_cards; p != 0; p = p->link)
262         if (p->link == now)
263             return p;
264     return now;
265 }
266
267 /*******************************************************************************/
268
269 static int
270 form_virtualize(WINDOW *w)
271 {
272     int c = wgetch(w);
273
274     switch (c) {
275     case CTRL('W'):
276         return (MAX_FORM_COMMAND + 4);
277     case CTRL('N'):
278         return (MAX_FORM_COMMAND + 3);
279     case CTRL('P'):
280         return (MAX_FORM_COMMAND + 2);
281     case CTRL('Q'):
282     case 033:
283         return (MAX_FORM_COMMAND + 1);
284
285     case KEY_BACKSPACE:
286         return (REQ_DEL_PREV);
287     case KEY_DC:
288         return (REQ_DEL_CHAR);
289     case KEY_LEFT:
290         return (REQ_LEFT_CHAR);
291     case KEY_RIGHT:
292         return (REQ_RIGHT_CHAR);
293
294     case KEY_DOWN:
295     case KEY_NEXT:
296         return (REQ_NEXT_FIELD);
297     case KEY_UP:
298     case KEY_PREVIOUS:
299         return (REQ_PREV_FIELD);
300
301     default:
302         return (c);
303     }
304 }
305
306 static FIELD **
307 make_fields(CARD * p, int form_high, int form_wide)
308 {
309     FIELD **f = (FIELD **) calloc(3, sizeof(FIELD *));
310
311     f[0] = new_field(1, form_wide, 0, 0, 0, 0);
312     set_field_back(f[0], A_REVERSE);
313     set_field_buffer(f[0], 0, p->title);
314
315     f[1] = new_field(form_high - 1, form_wide, 1, 0, 0, 0);
316     set_field_buffer(f[1], 0, p->content);
317     set_field_just(f[1], JUSTIFY_LEFT);
318
319     f[2] = 0;
320     return f;
321 }
322
323 static void
324 show_legend(void)
325 {
326     erase();
327     move(LINES - 3, 0);
328     addstr("^Q/ESC -- exit form            ^W   -- writes data to file\n");
329     addstr("^N   -- go to next card        ^P   -- go to previous card\n");
330     addstr("Arrow keys move left/right within a field, up/down between fields");
331 }
332
333 #if (defined(KEY_RESIZE) && HAVE_WRESIZE) || NO_LEAKS
334 static void
335 free_form_fields(FIELD ** f)
336 {
337     int n;
338
339     for (n = 0; f[n] != 0; ++n) {
340         free_field(f[n]);
341     }
342     free(f);
343 }
344 #endif
345
346 /*******************************************************************************/
347
348 static void
349 cardfile(char *fname)
350 {
351     WINDOW *win;
352     CARD *p;
353     CARD *top_card;
354     int visible_cards = count_cards();
355     int panel_wide = COLS - (visible_cards * OFFSET_CARD);
356     int panel_high = LINES - (visible_cards * OFFSET_CARD) - 5;
357     int form_wide = panel_wide - 2;
358     int form_high = panel_high - 2;
359     int y = (visible_cards - 1) * OFFSET_CARD;
360     int x = 0;
361     int ch = ERR;
362     int last_ch;
363     int finished = FALSE;
364
365     show_legend();
366
367     /* make a panel for each CARD */
368     for (p = all_cards; p != 0; p = p->link) {
369
370         win = newwin(panel_high, panel_wide, y, x);
371         keypad(win, TRUE);
372         p->panel = new_panel(win);
373         box(win, 0, 0);
374
375         p->form = new_form(make_fields(p, form_high, form_wide));
376         set_form_win(p->form, win);
377         set_form_sub(p->form, derwin(win, form_high, form_wide, 1, 1));
378         post_form(p->form);
379
380         y -= OFFSET_CARD;
381         x += OFFSET_CARD;
382     }
383
384     order_cards(top_card = all_cards, visible_cards);
385
386     while (!finished) {
387         update_panels();
388         doupdate();
389
390         last_ch = ch;
391         ch = form_virtualize(panel_window(top_card->panel));
392         switch (form_driver(top_card->form, ch)) {
393         case E_OK:
394             break;
395         case E_UNKNOWN_COMMAND:
396             switch (ch) {
397             case MAX_FORM_COMMAND + 1:
398                 finished = TRUE;
399                 break;
400             case MAX_FORM_COMMAND + 2:
401                 top_card = prev_card(top_card);
402                 order_cards(top_card, visible_cards);
403                 break;
404             case MAX_FORM_COMMAND + 3:
405                 top_card = next_card(top_card);
406                 order_cards(top_card, visible_cards);
407                 break;
408             case MAX_FORM_COMMAND + 4:
409                 write_data(fname);
410                 break;
411 #if defined(KEY_RESIZE) && HAVE_WRESIZE
412             case KEY_RESIZE:
413                 /* resizeterm already did "something" reasonable, but it cannot
414                  * know much about layout.  So let's make it nicer.
415                  */
416                 panel_wide = COLS - (visible_cards * OFFSET_CARD);
417                 panel_high = LINES - (visible_cards * OFFSET_CARD) - 5;
418
419                 form_wide = panel_wide - 2;
420                 form_high = panel_high - 2;
421
422                 y = (visible_cards - 1) * OFFSET_CARD;
423                 x = 0;
424
425                 show_legend();
426                 for (p = all_cards; p != 0; p = p->link) {
427                     FIELD **oldf = form_fields(p->form);
428                     WINDOW *olds = form_sub(p->form);
429
430                     win = form_win(p->form);
431
432                     /* move and resize the card as needed
433                      * FIXME: if the windows are shrunk too much, this won't do
434                      */
435                     mvwin(win, y, x);
436                     wresize(win, panel_high, panel_wide);
437
438                     /* reconstruct each form.  Forms are not resizable, and
439                      * there appears to be no good way to reload the text in
440                      * a resized window.
441                      */
442                     werase(win);
443
444                     unpost_form(p->form);
445                     free_form(p->form);
446
447                     p->form = new_form(make_fields(p, form_high, form_wide));
448                     set_form_win(p->form, win);
449                     set_form_sub(p->form, derwin(win, form_high, form_wide,
450                                                  1, 1));
451                     post_form(p->form);
452
453                     free_form_fields(oldf);
454                     delwin(olds);
455
456                     box(win, 0, 0);
457
458                     y -= OFFSET_CARD;
459                     x += OFFSET_CARD;
460                 }
461                 break;
462 #endif
463             default:
464                 beep();
465                 break;
466             }
467             break;
468         default:
469             flash();
470             break;
471         }
472     }
473 #if NO_LEAKS
474     while (all_cards != 0) {
475         FIELD **f;
476         int count;
477
478         p = all_cards;
479         all_cards = all_cards->link;
480
481         f = form_fields(p->form);
482         count = field_count(p->form);
483
484         unpost_form(p->form);   /* ...so we can free it */
485         free_form(p->form);     /* this also disconnects the fields */
486
487         free_form_fields(f);
488
489         del_panel(p->panel);
490         free(p->title);
491         free(p->content);
492         free(p);
493     }
494 #endif
495 }
496
497 /*******************************************************************************/
498
499 int
500 main(int argc, char *argv[])
501 {
502     int n;
503
504     setlocale(LC_ALL, "");
505
506     initscr();
507     cbreak();
508     noecho();
509
510     if (argc > 1) {
511         for (n = 1; n < argc; n++)
512             read_data(argv[n]);
513         if (count_cards() == 0)
514             new_card();
515         cardfile(argv[1]);
516     } else {
517         read_data(default_name);
518         if (count_cards() == 0)
519             new_card();
520         cardfile(default_name);
521     }
522
523     endwin();
524
525     ExitProgram(EXIT_SUCCESS);
526 }
527 #else
528 int
529 main(void)
530 {
531     printf("This program requires the curses form and panel libraries\n");
532     ExitProgram(EXIT_FAILURE);
533 }
534 #endif