ncurses 6.2 - patch 20200509
[ncurses.git] / test / move_field.c
1 /****************************************************************************
2  * Copyright 2020 Thomas E. Dickey                                          *
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  * $Id: move_field.c,v 1.7 2020/05/09 12:52:00 tom Exp $
30  *
31  * Demonstrate move_field().
32  */
33
34 #include <test.priv.h>
35
36 #if USE_LIBFORM
37
38 #include <edit_field.h>
39 #include <popup_msg.h>
40
41 #ifdef HAVE_NETBSD_FORM_H
42 #define form_field_row(field) (field)->form_row
43 #define form_field_col(field) (field)->form_col
44 #else   /* e.g., SVr4, ncurses */
45 #define form_field_row(field) (field)->frow
46 #define form_field_col(field) (field)->fcol
47 #endif
48
49 #define DO_DEMO CTRL('F')       /* actual key for toggling demo-mode */
50 #define MY_DEMO EDIT_FIELD('f') /* internal request-code */
51
52 static char empty[] = "";
53 static FIELD *all_fields[100];
54
55 /* *INDENT-OFF* */
56 static struct {
57     int code;
58     int result;
59     const char *help;
60 } commands[] = {
61     { CTRL('A'),     REQ_BEG_FIELD,   "go to beginning of field" },
62     { CTRL('D'),     REQ_DOWN_FIELD,  "move downward to field" },
63     { CTRL('E'),     REQ_END_FIELD,   "go to end of field" },
64     { CTRL('H'),     REQ_DEL_PREV,    "delete previous character" },
65     { CTRL('I'),     REQ_NEXT_FIELD,  "go to next field" },
66     { CTRL('K'),     REQ_CLR_EOF,     "clear to end of field" },
67     { CTRL('N'),     REQ_NEXT_FIELD,  "go to next field" },
68     { CTRL('P'),     REQ_PREV_FIELD,  "go to previous field" },
69     { CTRL('Q'),     MY_QUIT,         "exit form" },
70     { CTRL('U'),     REQ_UP_FIELD,    "move upward to field" },
71     { CTRL('W'),     REQ_NEXT_WORD,   "go to next word" },
72     { CTRL('X'),     REQ_CLR_FIELD,   "clear field" },
73     { CTRL('['),     MY_QUIT,         "exit form" },
74     { KEY_F(1),      MY_HELP,         "show this screen", },
75     { KEY_BACKSPACE, REQ_DEL_PREV,    "delete previous character" },
76     { KEY_BTAB,      REQ_PREV_FIELD,  "go to previous field" },
77     { KEY_DOWN,      REQ_DOWN_CHAR,   "move down 1 character" },
78     { KEY_END,       REQ_LAST_FIELD,  "go to last field" },
79     { KEY_HOME,      REQ_FIRST_FIELD, "go to first field" },
80     { KEY_LEFT,      REQ_LEFT_CHAR,   "move left 1 character" },
81     { KEY_NEXT,      REQ_NEXT_FIELD,  "go to next field" },
82     { KEY_PREVIOUS,  REQ_PREV_FIELD,  "go to previous field" },
83     { KEY_RIGHT,     REQ_RIGHT_CHAR,  "move right 1 character" },
84     { KEY_UP,        REQ_UP_CHAR,     "move up 1 character" },
85     { DO_DEMO,       MY_DEMO,         "move current field with cursor keys" }
86 };
87 /* *INDENT-ON* */
88
89 static void
90 my_help_edit_field(void)
91 {
92     int used = 0;
93     unsigned n;
94     char **msgs = typeCalloc(char *, 3 + SIZEOF(commands));
95
96     msgs[used++] = strdup("Defined form edit/traversal keys:");
97     for (n = 0; n < SIZEOF(commands); ++n) {
98         char *msg;
99         const char *name;
100         const char *code = keyname(commands[n].code);
101         size_t need = 5;
102 #ifdef NCURSES_VERSION
103         if ((name = form_request_name(commands[n].result)) == 0)
104 #endif
105             name = commands[n].help;
106         need = 5 + strlen(code) + strlen(name);
107         msg = typeMalloc(char, need);
108         _nc_SPRINTF(msg, _nc_SLIMIT(need) "%s -- %s", code, name);
109         msgs[used++] = msg;
110     }
111     msgs[used++] =
112         strdup("Arrow keys move within a field as you would expect.");
113     msgs[used] = 0;
114     popup_msg2(stdscr, msgs);
115     for (n = 0; msgs[n] != 0; ++n) {
116         free(msgs[n]);
117     }
118     free(msgs);
119 }
120
121 static FIELD *
122 make_label(const char *label, int frow, int fcol)
123 {
124     FIELD *f = new_field(1, (int) strlen(label), frow, fcol, 0, 0);
125
126     if (f) {
127         set_field_buffer(f, 0, label);
128         set_field_opts(f, (int) ((unsigned) field_opts(f) & ~O_ACTIVE));
129     }
130     return (f);
131 }
132
133 static FIELD *
134 make_field(int frow, int fcol, int rows, int cols)
135 {
136     FIELD *f = new_field(rows, cols, frow, fcol, 0, 1);
137
138     if (f) {
139         set_field_back(f, A_UNDERLINE);
140         init_edit_field(f, empty);
141     }
142     return (f);
143 }
144
145 static void
146 erase_form(FORM *f)
147 {
148     WINDOW *w = form_win(f);
149     WINDOW *s = form_sub(f);
150
151     unpost_form(f);
152     werase(w);
153     wrefresh(w);
154     delwin(s);
155     delwin(w);
156 }
157
158 static FieldAttrs *
159 my_field_attrs(FIELD *f)
160 {
161     return (FieldAttrs *) field_userptr(f);
162 }
163
164 static int
165 buffer_length(FIELD *f)
166 {
167     return my_field_attrs(f)->row_lengths[0];
168 }
169
170 static void
171 set_buffer_length(FIELD *f, int length)
172 {
173     my_field_attrs(f)->row_lengths[0] = length;
174 }
175
176 static int
177 offset_in_field(FORM *form)
178 {
179     FIELD *field = current_field(form);
180     int currow, curcol;
181
182     form_getyx(form, currow, curcol);
183     return curcol + currow * (int) field->dcols;
184 }
185
186 static void
187 inactive_field(FIELD *f)
188 {
189     set_field_back(f, my_field_attrs(f)->background);
190 }
191
192 static int
193 my_edit_field(FORM *form, int *result)
194 {
195     int ch = wgetch(form_win(form));
196     int status;
197     FIELD *before;
198     unsigned n;
199     int length;
200     int before_row;
201     int before_col;
202     int before_off = offset_in_field(form);
203
204     form_getyx(form, before_row, before_col);
205     before = current_field(form);
206     set_field_back(before, A_NORMAL);
207     if (ch <= KEY_MAX) {
208         set_field_back(before, A_REVERSE);
209     } else if (ch <= MAX_FORM_COMMAND) {
210         inactive_field(before);
211     }
212
213     *result = ch;
214     for (n = 0; n < SIZEOF(commands); ++n) {
215         if (commands[n].code == ch) {
216             *result = commands[n].result;
217             break;
218         }
219     }
220
221     status = form_driver(form, *result);
222
223     if (status == E_OK) {
224         bool modified = TRUE;
225
226         length = buffer_length(before);
227         if (length < before_off)
228             length = before_off;
229         switch (*result) {
230         case REQ_CLR_EOF:
231             length = before_off;
232             break;
233         case REQ_CLR_EOL:
234             if ((int) (before_row + 1) == (int) (before->rows))
235                 length = before_off;
236             break;
237         case REQ_CLR_FIELD:
238             length = 0;
239             break;
240         case REQ_DEL_CHAR:
241             if (length > before_off)
242                 --length;
243             break;
244         case REQ_DEL_PREV:
245             if (length > 0) {
246                 if (before_col > 0) {
247                     --length;
248                 } else if (before_row > 0) {
249                     length -= (int) before->cols + before_col;
250                 }
251             }
252             break;
253         case REQ_NEW_LINE:
254             length += (int) before->cols;
255             break;
256
257         default:
258             modified = (ch < MIN_FORM_COMMAND
259                         && isprint(ch));
260             break;
261         }
262
263         /*
264          * If we do not force a re-validation, then field_buffer 0 will
265          * be lagging by one character.
266          */
267         if (modified && form_driver(form, REQ_VALIDATION) == E_OK && *result
268             < MIN_FORM_COMMAND)
269             ++length;
270
271         set_buffer_length(before, length);
272     }
273
274     if (current_field(form) != before)
275         inactive_field(before);
276     return status;
277 }
278
279 static FIELD **
280 copy_fields(FIELD **source, size_t length)
281 {
282     FIELD **target = calloc(length + 1, sizeof(FIELD *));
283     memcpy(target, source, length * sizeof(FIELD *));
284     return target;
285 }
286
287 /* display a status message to show what's happening */
288 static void
289 show_status(FORM *form, FIELD *field)
290 {
291     WINDOW *sub = form_sub(form);
292     int currow, curcol;
293
294     getyx(stdscr, currow, curcol);
295     mvprintw(LINES - 1, 0,
296              "Field at [%d,%d].  Press %s to quit moving.",
297              getbegy(sub) + form_field_row(field),
298              getbegx(sub) + form_field_col(field),
299              keyname(DO_DEMO));
300     clrtobot();
301     move(currow, curcol);
302     refresh();
303 }
304
305 /*
306  * Move the current label+field in response to cursor-keys (or h,j,k,l) until
307  * a control/F is read.
308  */
309 static void
310 do_demo(FORM *form)
311 {
312     int count = field_count(form);
313     FIELD *my_field = current_field(form);
314
315     if (count > 0 && my_field != NULL) {
316         size_t needed = (size_t) count;
317         FIELD **old_fields = copy_fields(form_fields(form), needed);
318         FIELD **new_fields = copy_fields(form_fields(form), needed);
319         int ch;
320
321         if (old_fields != NULL && new_fields != NULL) {
322             bool found = FALSE;
323
324             /* TODO: move the label too, in parallel with the editing field */
325
326             /* remove the current field from the newer list */
327             for (ch = 0; ch <= count; ++ch) {
328                 if (found) {
329                     new_fields[ch - 1] = new_fields[ch];
330                 } else if (new_fields[ch] == my_field) {
331                     found = TRUE;
332                 }
333             }
334
335             if (found) {
336                 int currow, curcol;
337
338                 getyx(stdscr, currow, curcol);
339
340                 show_status(form, my_field);
341                 ch = '?';
342                 while ((ch = wgetch(form_win(form))) != DO_DEMO) {
343                     int field_y = form_field_row(my_field);
344                     int field_x = form_field_col(my_field);
345
346                     switch (ch) {
347                     case 'h':
348                     case KEY_LEFT:
349                         if (field_x > 0)
350                             field_x--;
351                         break;
352                     case 'j':
353                     case KEY_DOWN:
354                         field_y++;
355                         break;
356                     case 'k':
357                     case KEY_UP:
358                         if (field_y > 0)
359                             field_y--;
360                         break;
361                     case 'l':
362                     case KEY_RIGHT:
363                         field_x++;
364                         break;
365                     case CTRL('Q'):
366                     case CTRL('['):
367                         ch = DO_DEMO;
368                         /* FALLTHRU */
369                     case DO_DEMO:
370                         break;
371                     default:
372                         continue;
373                     }
374
375                     if (ch == DO_DEMO)
376                         break;
377
378                     /* alter connected fields temporarily to move the field */
379                     unpost_form(form);
380                     set_form_fields(form, new_fields);
381                     post_form(form);
382
383                     /* TODO: update screen position on success */
384                     move_field(my_field, field_y, field_x);
385
386                     /* restore the form's list of fields */
387                     unpost_form(form);
388                     set_form_fields(form, old_fields);
389                     post_form(form);
390
391                     show_status(form, my_field);
392                 }
393
394                 /* cleanup */
395                 move(LINES - 1, 0);
396                 clrtobot();
397                 move(currow, curcol);
398                 refresh();
399             }
400         }
401         free(new_fields);
402     }
403 }
404
405 static int
406 my_form_driver(FORM *form, int c)
407 {
408     switch (c) {
409     case MY_QUIT:
410         if (form_driver(form, REQ_VALIDATION) == E_OK)
411             return (TRUE);
412         break;
413     case MY_HELP:
414         my_help_edit_field();
415         break;
416     case MY_DEMO:
417         do_demo(form);
418         break;
419     default:
420         beep();
421         break;
422     }
423     return (FALSE);
424 }
425
426 static void
427 demo_forms(void)
428 {
429     FORM *form;
430     int c;
431     unsigned n = 0;
432     const char *fname;
433
434     /* describe the form */
435     all_fields[n++] = make_label("Sample Form", 0, 15);
436
437     fname = "Last Name";
438     all_fields[n++] = make_label(fname, 2, 0);
439     all_fields[n++] = make_field(3, 0, 1, 18);
440     set_field_type(all_fields[n - 1], TYPE_ALPHA, 1);
441
442     fname = "First Name";
443     all_fields[n++] = make_label(fname, 2, 20);
444     all_fields[n++] = make_field(3, 20, 1, 12);
445     set_field_type(all_fields[n - 1], TYPE_ALPHA, 1);
446
447     fname = "Middle Name";
448     all_fields[n++] = make_label(fname, 2, 34);
449     all_fields[n++] = make_field(3, 34, 1, 12);
450     set_field_type(all_fields[n - 1], TYPE_ALPHA, 1);
451
452     fname = "Comments";
453     all_fields[n++] = make_label(fname, 5, 0);
454     all_fields[n++] = make_field(6, 0, 4, 46);
455     init_edit_field(all_fields[n - 1], empty);
456
457     all_fields[n] = (FIELD *) 0;
458
459     if ((form = new_form(all_fields)) != 0) {
460         int finished = 0;
461
462         post_form(form);
463
464         while (!finished) {
465             switch (my_edit_field(form, &c)) {
466             case E_OK:
467                 break;
468             case E_UNKNOWN_COMMAND:
469                 finished = my_form_driver(form, c);
470                 break;
471             default:
472                 beep();
473                 break;
474             }
475         }
476
477         erase_form(form);
478
479         free_form(form);
480     }
481     for (c = 0; all_fields[c] != 0; c++) {
482         free_edit_field(all_fields[c]);
483         free_field(all_fields[c]);
484     }
485     noraw();
486     nl();
487 }
488
489 int
490 main(void)
491 {
492     setlocale(LC_ALL, "");
493
494     initscr();
495     cbreak();
496     noecho();
497     raw();
498     nonl();                     /* lets us read ^M's */
499     intrflush(stdscr, FALSE);
500     keypad(stdscr, TRUE);
501
502     if (has_colors()) {
503         start_color();
504         init_pair(1, COLOR_WHITE, COLOR_BLUE);
505         init_pair(2, COLOR_GREEN, COLOR_BLACK);
506         init_pair(3, COLOR_CYAN, COLOR_BLACK);
507         bkgd((chtype) COLOR_PAIR(1));
508         refresh();
509     }
510
511     demo_forms();
512
513     endwin();
514     ExitProgram(EXIT_SUCCESS);
515 }
516
517 #else
518 int
519 main(void)
520 {
521     printf("This program requires the curses form library\n");
522     ExitProgram(EXIT_FAILURE);
523 }
524 #endif