test/dup_field.c

   1 /****************************************************************************
   2  * Copyright 2020-2021,2022 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: dup_field.c,v 1.6 2022/05/21 20:59:26 tom Exp $
  30  *
  31  * Demonstrate dup_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 #define DO_DEMO CTRL('F')       /* actual key for toggling demo-mode */
  42 #define MY_DEMO EDIT_FIELD('f') /* internal request-code */
  43
  44 static char empty[] = "";
  45 static FIELD *all_fields[100];
  46 /* *INDENT-OFF* */
  47 static struct {
  48     int code;
  49     int result;
  50     const char *help;
  51 } commands[] = {
  52     { CTRL('A'),     REQ_BEG_FIELD,   "go to beginning of field" },
  53     { CTRL('D'),     REQ_DOWN_FIELD,  "move downward to field" },
  54     { CTRL('E'),     REQ_END_FIELD,   "go to end of field" },
  55     { CTRL('H'),     REQ_DEL_PREV,    "delete previous character" },
  56     { CTRL('I'),     REQ_NEXT_FIELD,  "go to next field" },
  57     { CTRL('K'),     REQ_CLR_EOF,     "clear to end of field" },
  58     { CTRL('N'),     REQ_NEXT_FIELD,  "go to next field" },
  59     { CTRL('P'),     REQ_PREV_FIELD,  "go to previous field" },
  60     { CTRL('Q'),     MY_QUIT,         "exit form" },
  61     { CTRL('U'),     REQ_UP_FIELD,    "move upward to field" },
  62     { CTRL('W'),     REQ_NEXT_WORD,   "go to next word" },
  63     { CTRL('X'),     REQ_CLR_FIELD,   "clear field" },
  64     { CTRL('['),     MY_QUIT,         "exit form" },
  65     { KEY_F(1),      MY_HELP,         "show this screen", },
  66     { KEY_BACKSPACE, REQ_DEL_PREV,    "delete previous character" },
  67     { KEY_BTAB,      REQ_PREV_FIELD,  "go to previous field" },
  68     { KEY_DOWN,      REQ_DOWN_CHAR,   "move down 1 character" },
  69     { KEY_END,       REQ_LAST_FIELD,  "go to last field" },
  70     { KEY_HOME,      REQ_FIRST_FIELD, "go to first field" },
  71     { KEY_LEFT,      REQ_LEFT_CHAR,   "move left 1 character" },
  72     { KEY_NEXT,      REQ_NEXT_FIELD,  "go to next field" },
  73     { KEY_PREVIOUS,  REQ_PREV_FIELD,  "go to previous field" },
  74     { KEY_RIGHT,     REQ_RIGHT_CHAR,  "move right 1 character" },
  75     { KEY_UP,        REQ_UP_CHAR,     "move up 1 character" },
  76     { DO_DEMO,       MY_DEMO,         "duplicate current field" }
  77 };
  78 /* *INDENT-ON* */
  79
  80 static void
  81 my_help_edit_field(void)
  82 {
  83     int used = 0;
  84     unsigned n;
  85     char **msgs = typeCalloc(char *, 3 + SIZEOF(commands));
  86
  87     msgs[used++] = strdup("Defined form edit/traversal keys:");
  88     for (n = 0; n < SIZEOF(commands); ++n) {
  89         char *msg;
  90         const char *name;
  91         const char *code = keyname(commands[n].code);
  92         size_t need = 5;
  93 #ifdef NCURSES_VERSION
  94         if ((name = form_request_name(commands[n].result)) == 0)
  95 #endif
  96             name = commands[n].help;
  97         need = 5 + strlen(code) + strlen(name);
  98         msg = typeMalloc(char, need);
  99         _nc_SPRINTF(msg, _nc_SLIMIT(need) "%s -- %s", code, name);
 100         msgs[used++] = msg;
 101     }
 102     msgs[used++] =
 103         strdup("Arrow keys move within a field as you would expect.");
 104     msgs[used] = 0;
 105     popup_msg2(stdscr, msgs);
 106     for (n = 0; msgs[n] != 0; ++n) {
 107         free(msgs[n]);
 108     }
 109     free(msgs);
 110 }
 111
 112 static FIELD *
 113 make_label(const char *label, int frow, int fcol)
 114 {
 115     FIELD *f = new_field(1, (int) strlen(label), frow, fcol, 0, 0);
 116
 117     if (f) {
 118         set_field_buffer(f, 0, label);
 119         set_field_opts(f, (int) ((unsigned) field_opts(f) & ~O_ACTIVE));
 120     }
 121     return (f);
 122 }
 123
 124 static FIELD *
 125 make_field(int frow, int fcol, int rows, int cols)
 126 {
 127     FIELD *f = new_field(rows, cols, frow, fcol, 0, 1);
 128
 129     if (f) {
 130         set_field_back(f, A_UNDERLINE);
 131         init_edit_field(f, empty);
 132     }
 133     return (f);
 134 }
 135
 136 static void
 137 erase_form(FORM *f)
 138 {
 139     WINDOW *w = form_win(f);
 140     WINDOW *s = form_sub(f);
 141
 142     unpost_form(f);
 143     werase(w);
 144     wrefresh(w);
 145     delwin(s);
 146 }
 147
 148 static FieldAttrs *
 149 my_field_attrs(FIELD *f)
 150 {
 151     return (FieldAttrs *) field_userptr(f);
 152 }
 153
 154 static int
 155 buffer_length(FIELD *f)
 156 {
 157     return my_field_attrs(f)->row_lengths[0];
 158 }
 159
 160 static void
 161 set_buffer_length(FIELD *f, int length)
 162 {
 163     my_field_attrs(f)->row_lengths[0] = length;
 164 }
 165
 166 static int
 167 offset_in_field(FORM *form)
 168 {
 169     FIELD *field = current_field(form);
 170     int currow, curcol;
 171
 172     form_getyx(form, currow, curcol);
 173     return curcol + currow * (int) field->dcols;
 174 }
 175
 176 static void
 177 inactive_field(FIELD *f)
 178 {
 179     set_field_back(f, my_field_attrs(f)->background);
 180 }
 181
 182 static int
 183 my_edit_field(FORM *form, int *result)
 184 {
 185     int ch = wgetch(form_win(form));
 186     int status;
 187     FIELD *before;
 188     unsigned n;
 189     int before_row;
 190     int before_col;
 191     int before_off = offset_in_field(form);
 192
 193     form_getyx(form, before_row, before_col);
 194     before = current_field(form);
 195     set_field_back(before, A_NORMAL);
 196     if (ch <= KEY_MAX) {
 197         set_field_back(before, A_REVERSE);
 198     } else if (ch <= MAX_FORM_COMMAND) {
 199         inactive_field(before);
 200     }
 201
 202     *result = ch;
 203     for (n = 0; n < SIZEOF(commands); ++n) {
 204         if (commands[n].code == ch) {
 205             *result = commands[n].result;
 206             break;
 207         }
 208     }
 209
 210     status = form_driver(form, *result);
 211
 212     if (status == E_OK) {
 213         bool modified = TRUE;
 214         int length = buffer_length(before);
 215
 216         if (length < before_off)
 217             length = before_off;
 218         switch (*result) {
 219         case REQ_CLR_EOF:
 220             length = before_off;
 221             break;
 222         case REQ_CLR_EOL:
 223             if ((int) (before_row + 1) == (int) (before->rows))
 224                 length = before_off;
 225             break;
 226         case REQ_CLR_FIELD:
 227             length = 0;
 228             break;
 229         case REQ_DEL_CHAR:
 230             if (length > before_off)
 231                 --length;
 232             break;
 233         case REQ_DEL_PREV:
 234             if (length > 0) {
 235                 if (before_col > 0) {
 236                     --length;
 237                 } else if (before_row > 0) {
 238                     length -= (int) before->cols + before_col;
 239                 }
 240             }
 241             break;
 242         case REQ_NEW_LINE:
 243             length += (int) before->cols;
 244             break;
 245
 246         default:
 247             modified = (ch < MIN_FORM_COMMAND
 248                         && isprint(ch));
 249             break;
 250         }
 251
 252         /*
 253          * If we do not force a re-validation, then field_buffer 0 will
 254          * be lagging by one character.
 255          */
 256         if (modified && form_driver(form, REQ_VALIDATION) == E_OK && *result
 257             < MIN_FORM_COMMAND)
 258             ++length;
 259
 260         set_buffer_length(before, length);
 261     }
 262
 263     if (current_field(form) != before)
 264         inactive_field(before);
 265     return status;
 266 }
 267
 268 static FIELD **
 269 copy_fields(FIELD **source, FIELD *extra, size_t length)
 270 {
 271     FIELD **target = typeCalloc(FIELD *, length + 1);
 272     memcpy(target, source, length * sizeof(FIELD *));
 273     target[length] = extra;
 274     return target;
 275 }
 276
 277 static void
 278 do_demo(FORM *form)
 279 {
 280     int count = field_count(form);
 281     FIELD *my_field = current_field(form);
 282     FIELD **old_fields = form_fields(form);
 283
 284     if (count > 0 && old_fields != NULL && my_field != NULL) {
 285         FIELD **new_fields = copy_fields(old_fields,
 286                                          dup_field(my_field,
 287                                                    form_field_row(my_field)
 288                                                    + 1,
 289                                                    form_field_col(my_field)),
 290                                          (size_t) count);
 291         if (new_fields != NULL)
 292             set_form_fields(form, new_fields);
 293     }
 294 }
 295
 296 static int
 297 my_form_driver(FORM *form, int c)
 298 {
 299     switch (c) {
 300     case MY_QUIT:
 301         if (form_driver(form, REQ_VALIDATION) == E_OK)
 302             return (TRUE);
 303         break;
 304     case MY_HELP:
 305         my_help_edit_field();
 306         break;
 307     case MY_DEMO:
 308         do_demo(form);
 309         break;
 310     default:
 311         beep();
 312         break;
 313     }
 314     return (FALSE);
 315 }
 316
 317 static void
 318 demo_forms(void)
 319 {
 320     FORM *form;
 321     int c;
 322     unsigned n = 0;
 323     const char *fname;
 324
 325     /* describe the form */
 326     all_fields[n++] = make_label("Sample Form", 0, 15);
 327
 328     fname = "Last Name";
 329     all_fields[n++] = make_label(fname, 2, 0);
 330     all_fields[n++] = make_field(3, 0, 1, 18);
 331     set_field_type(all_fields[n - 1], TYPE_ALPHA, 1);
 332
 333     fname = "First Name";
 334     all_fields[n++] = make_label(fname, 2, 20);
 335     all_fields[n++] = make_field(3, 20, 1, 12);
 336     set_field_type(all_fields[n - 1], TYPE_ALPHA, 1);
 337
 338     fname = "Middle Name";
 339     all_fields[n++] = make_label(fname, 2, 34);
 340     all_fields[n++] = make_field(3, 34, 1, 12);
 341     set_field_type(all_fields[n - 1], TYPE_ALPHA, 1);
 342
 343     fname = "Comments";
 344     all_fields[n++] = make_label(fname, 5, 0);
 345     all_fields[n++] = make_field(6, 0, 4, 46);
 346     init_edit_field(all_fields[n - 1], empty);
 347
 348     all_fields[n] = (FIELD *) 0;
 349
 350     if ((form = new_form(all_fields)) != 0) {
 351         int finished = 0;
 352
 353         post_form(form);
 354
 355         while (!finished) {
 356             switch (my_edit_field(form, &c)) {
 357             case E_OK:
 358                 break;
 359             case E_UNKNOWN_COMMAND:
 360                 finished = my_form_driver(form, c);
 361                 break;
 362             default:
 363                 beep();
 364                 break;
 365             }
 366         }
 367
 368         erase_form(form);
 369
 370         free_form(form);
 371     }
 372     for (c = 0; all_fields[c] != 0; c++) {
 373         free_edit_field(all_fields[c]);
 374         free_field(all_fields[c]);
 375     }
 376     noraw();
 377     nl();
 378 }
 379
 380 int
 381 main(void)
 382 {
 383     setlocale(LC_ALL, "");
 384
 385     initscr();
 386     cbreak();
 387     noecho();
 388     raw();
 389     nonl();                     /* lets us read ^M's */
 390     intrflush(stdscr, FALSE);
 391     keypad(stdscr, TRUE);
 392
 393     if (has_colors()) {
 394         start_color();
 395         init_pair(1, COLOR_WHITE, COLOR_BLUE);
 396         init_pair(2, COLOR_GREEN, COLOR_BLACK);
 397         init_pair(3, COLOR_CYAN, COLOR_BLACK);
 398         bkgd((chtype) COLOR_PAIR(1));
 399         refresh();
 400     }
 401
 402     demo_forms();
 403
 404     endwin();
 405     ExitProgram(EXIT_SUCCESS);
 406 }
 407
 408 #else
 409 int
 410 main(void)
 411 {
 412     printf("This program requires the curses form library\n");
 413     ExitProgram(EXIT_FAILURE);
 414 }
 415 #endif