test/edit_field.c

   1 /****************************************************************************
   2  * Copyright 2019,2020 Thomas E. Dickey                                     *
   3  * Copyright 2003-2014,2017 Free Software Foundation, Inc.                  *
   4  *                                                                          *
   5  * Permission is hereby granted, free of charge, to any person obtaining a  *
   6  * copy of this software and associated documentation files (the            *
   7  * "Software"), to deal in the Software without restriction, including      *
   8  * without limitation the rights to use, copy, modify, merge, publish,      *
   9  * distribute, distribute with modifications, sublicense, and/or sell       *
  10  * copies of the Software, and to permit persons to whom the Software is    *
  11  * furnished to do so, subject to the following conditions:                 *
  12  *                                                                          *
  13  * The above copyright notice and this permission notice shall be included  *
  14  * in all copies or substantial portions of the Software.                   *
  15  *                                                                          *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
  17  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
  18  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
  19  * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
  20  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
  21  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
  22  * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
  23  *                                                                          *
  24  * Except as contained in this notice, the name(s) of the above copyright   *
  25  * holders shall not be used in advertising or otherwise to promote the     *
  26  * sale, use or other dealings in this Software without prior written       *
  27  * authorization.                                                           *
  28  ****************************************************************************/
  29 /*
  30  * $Id: edit_field.c,v 1.31 2020/02/02 23:34:34 tom Exp $
  31  *
  32  * A wrapper for form_driver() which keeps track of the user's editing changes
  33  * for each field, and makes the resulting length available as a
  34  * null-terminated string in field_buffer(field,1).
  35  *
  36  * Thomas Dickey - 2003/4/26.
  37  */
  38
  39 #include <test.priv.h>
  40
  41 #if USE_LIBFORM
  42
  43 #include <edit_field.h>
  44 #include <popup_msg.h>
  45
  46 static struct {
  47     int code;
  48     int result;
  49     const char *help;
  50 } commands[] = {
  51
  52     {
  53         CTRL('A'), REQ_NEXT_CHOICE, ""
  54     },
  55     {
  56         CTRL('B'), REQ_PREV_WORD, "go to previous word"
  57     },
  58     {
  59         CTRL('C'), REQ_CLR_EOL, "clear to end of line"
  60     },
  61     {
  62         CTRL('D'), REQ_DOWN_FIELD, "move downward to field"
  63     },
  64     {
  65         CTRL('E'), REQ_END_FIELD, "go to end of field"
  66     },
  67     {
  68         CTRL('F'), REQ_NEXT_PAGE, "go to next page"
  69     },
  70     {
  71         CTRL('G'), REQ_DEL_WORD, "delete current word"
  72     },
  73     {
  74         CTRL('H'), REQ_DEL_PREV, "delete previous character"
  75     },
  76     {
  77         CTRL('I'), REQ_INS_CHAR, "insert character"
  78     },
  79     {
  80         CTRL('K'), REQ_CLR_EOF, "clear to end of field"
  81     },
  82     {
  83         CTRL('L'), REQ_LEFT_FIELD, "go to field to left"
  84     },
  85     {
  86         CTRL('M'), REQ_NEW_LINE, "insert/overlay new line"
  87     },
  88     {
  89         CTRL('N'), REQ_NEXT_FIELD, "go to next field"
  90     },
  91     {
  92         CTRL('O'), REQ_INS_LINE, "insert blank line at cursor"
  93     },
  94     {
  95         CTRL('P'), REQ_PREV_FIELD, "go to previous field"
  96     },
  97     {
  98         CTRL('Q'), MY_QUIT, "exit form"
  99     },
 100     {
 101         CTRL('R'), REQ_RIGHT_FIELD, "go to field to right"
 102     },
 103     {
 104         CTRL('S'), REQ_BEG_FIELD, "go to beginning of field"
 105     },
 106     {
 107         CTRL('T'), MY_EDT_MODE, "toggle O_EDIT mode, clear field status",
 108     },
 109     {
 110         CTRL('U'), REQ_UP_FIELD, "move upward to field"
 111     },
 112     {
 113         CTRL('V'), REQ_DEL_CHAR, "delete character"
 114     },
 115     {
 116         CTRL('W'), REQ_NEXT_WORD, "go to next word"
 117     },
 118     {
 119         CTRL('X'), REQ_CLR_FIELD, "clear field"
 120     },
 121     {
 122         CTRL('Y'), REQ_DEL_LINE, "delete line"
 123     },
 124     {
 125         CTRL('Z'), REQ_PREV_CHOICE, ""
 126     },
 127     {
 128         CTRL('['), MY_QUIT, "exit form"
 129     },
 130     {
 131         CTRL(']'), MY_INS_MODE, "toggle REQ_INS_MODE/REQ_OVL_MODE",
 132     },
 133     {
 134         KEY_F(1), MY_HELP, "show this screen",
 135     },
 136     {
 137         KEY_BACKSPACE, REQ_DEL_PREV, "delete previous character"
 138     },
 139     {
 140         KEY_DOWN, REQ_DOWN_CHAR, "move down 1 character"
 141     },
 142     {
 143         KEY_END, REQ_LAST_FIELD, "go to last field"
 144     },
 145     {
 146         KEY_HOME, REQ_FIRST_FIELD, "go to first field"
 147     },
 148     {
 149         KEY_LEFT, REQ_LEFT_CHAR, "move left 1 character"
 150     },
 151     {
 152         KEY_LL, REQ_LAST_FIELD, "go to last field"
 153     },
 154     {
 155         KEY_NEXT, REQ_NEXT_FIELD, "go to next field"
 156     },
 157     {
 158         KEY_NPAGE, REQ_NEXT_PAGE, "go to next page"
 159     },
 160     {
 161         KEY_PPAGE, REQ_PREV_PAGE, "go to previous page"
 162     },
 163     {
 164         KEY_PREVIOUS, REQ_PREV_FIELD, "go to previous field"
 165     },
 166     {
 167         KEY_RIGHT, REQ_RIGHT_CHAR, "move right 1 character"
 168     },
 169     {
 170         KEY_UP, REQ_UP_CHAR, "move up 1 character"
 171     }
 172 };
 173
 174 /*
 175  * Display a temporary window listing the keystroke-commands we recognize.
 176  */
 177 void
 178 help_edit_field(void)
 179 {
 180     int used = 0;
 181     unsigned n;
 182     char **msgs = typeCalloc(char *, 3 + SIZEOF(commands));
 183
 184     msgs[used++] = strdup("Defined form edit/traversal keys:");
 185     for (n = 0; n < SIZEOF(commands); ++n) {
 186         char *msg;
 187         const char *name;
 188         const char *code = keyname(commands[n].code);
 189         size_t need = 5;
 190 #ifdef NCURSES_VERSION
 191         if ((name = form_request_name(commands[n].result)) == 0)
 192 #endif
 193             name = commands[n].help;
 194         need = 5 + strlen(code) + strlen(name);
 195         msg = typeMalloc(char, need);
 196         _nc_SPRINTF(msg, _nc_SLIMIT(need) "%s -- %s", code, name);
 197         msgs[used++] = msg;
 198     }
 199     msgs[used++] =
 200         strdup("Arrow keys move within a field as you would expect.");
 201     msgs[used] = 0;
 202     popup_msg2(stdscr, msgs);
 203     for (n = 0; msgs[n] != 0; ++n) {
 204         free(msgs[n]);
 205     }
 206     free(msgs);
 207 }
 208
 209 static int
 210 offset_in_field(FORM *form)
 211 {
 212     FIELD *field = current_field(form);
 213     int currow, curcol;
 214
 215     form_getyx(form, currow, curcol);
 216     return curcol + currow * (int) field->dcols;
 217 }
 218
 219 static void
 220 inactive_field(FIELD *f)
 221 {
 222     set_field_back(f, field_attrs(f)->background);
 223 }
 224
 225 FieldAttrs *
 226 field_attrs(FIELD *f)
 227 {
 228     return (FieldAttrs *) field_userptr(f);
 229 }
 230
 231 static int
 232 buffer_length(FIELD *f)
 233 {
 234     return field_attrs(f)->row_lengths[0];
 235 }
 236
 237 static void
 238 set_buffer_length(FIELD *f, int length)
 239 {
 240     field_attrs(f)->row_lengths[0] = length;
 241 }
 242
 243 /*
 244  * The userptr is used in edit_field.c's inactive_field(), as well as for
 245  * keeping track of the actual lengths of lines in a multiline field.
 246  */
 247 void
 248 init_edit_field(FIELD *f, char *value)
 249 {
 250     char empty[1];
 251     FieldAttrs *ptr = field_attrs(f);
 252     if (ptr == 0) {
 253         int rows, cols, frow, fcol, nrow, nbuf;
 254
 255         ptr = typeCalloc(FieldAttrs, (size_t) 1);
 256         ptr->background = field_back(f);
 257         if (field_info(f, &rows, &cols, &frow, &fcol, &nrow, &nbuf) == E_OK) {
 258             ptr->row_count = nrow;
 259             ptr->row_lengths = typeCalloc(int, (size_t) nrow + 1);
 260         }
 261     }
 262     if (value == 0) {
 263         value = empty;
 264         *value = '\0';
 265     }
 266     set_field_userptr(f, (void *) ptr);
 267     set_field_buffer(f, 0, value);      /* will be formatted */
 268     set_field_buffer(f, 1, value);      /* will be unformatted */
 269     set_buffer_length(f, (int) strlen(value));
 270 }
 271
 272 int
 273 edit_field(FORM *form, int *result)
 274 {
 275     int ch = wgetch(form_win(form));
 276     int status;
 277     FIELD *before;
 278     unsigned n;
 279     int length;
 280     int before_row;
 281     int before_col;
 282     int before_off = offset_in_field(form);
 283
 284     form_getyx(form, before_row, before_col);
 285     before = current_field(form);
 286     set_field_back(before, A_NORMAL);
 287     if (ch <= KEY_MAX) {
 288         set_field_back(before, A_REVERSE);
 289     } else if (ch <= MAX_FORM_COMMAND) {
 290         inactive_field(before);
 291     }
 292
 293     *result = ch;
 294     for (n = 0; n < SIZEOF(commands); ++n) {
 295         if (commands[n].code == ch) {
 296             *result = commands[n].result;
 297             break;
 298         }
 299     }
 300
 301     status = form_driver(form, *result);
 302
 303     if (status == E_OK) {
 304         bool modified = TRUE;
 305
 306         length = buffer_length(before);
 307         if (length < before_off)
 308             length = before_off;
 309         switch (*result) {
 310         case REQ_CLR_EOF:
 311             length = before_off;
 312             break;
 313         case REQ_CLR_EOL:
 314             if ((int) (before_row + 1) == (int) (before->rows))
 315                 length = before_off;
 316             break;
 317         case REQ_CLR_FIELD:
 318             length = 0;
 319             break;
 320         case REQ_DEL_CHAR:
 321             if (length > before_off)
 322                 --length;
 323             break;
 324         case REQ_DEL_PREV:
 325             if (length > 0) {
 326                 if (before_col > 0) {
 327                     --length;
 328                 } else if (before_row > 0) {
 329                     length -= (int) before->cols + before_col;
 330                 }
 331             }
 332             break;
 333         case REQ_NEW_LINE:
 334             length += (int) before->cols;
 335             break;
 336 #if 0
 337             /* FIXME: finish these */
 338         case REQ_DEL_LINE:      /* delete line */
 339         case REQ_DEL_WORD:      /* delete word at cursor */
 340         case REQ_INS_CHAR:      /* insert blank char at cursor */
 341         case REQ_INS_LINE:      /* insert blank line at cursor */
 342         case REQ_INS_MODE:      /* begin insert mode */
 343         case REQ_OVL_MODE:      /* begin overlay mode */
 344 #endif
 345             /* ignore all of the motion commands */
 346         case REQ_SCR_BCHAR:     /* FALLTHRU */
 347         case REQ_SCR_BHPAGE:    /* FALLTHRU */
 348         case REQ_SCR_BLINE:     /* FALLTHRU */
 349         case REQ_SCR_BPAGE:     /* FALLTHRU */
 350         case REQ_SCR_FCHAR:     /* FALLTHRU */
 351         case REQ_SCR_FHPAGE:    /* FALLTHRU */
 352         case REQ_SCR_FLINE:     /* FALLTHRU */
 353         case REQ_SCR_FPAGE:     /* FALLTHRU */
 354         case REQ_SCR_HBHALF:    /* FALLTHRU */
 355         case REQ_SCR_HBLINE:    /* FALLTHRU */
 356         case REQ_SCR_HFHALF:    /* FALLTHRU */
 357         case REQ_SCR_HFLINE:    /* FALLTHRU */
 358         case REQ_BEG_FIELD:     /* FALLTHRU */
 359         case REQ_BEG_LINE:      /* FALLTHRU */
 360         case REQ_DOWN_CHAR:     /* FALLTHRU */
 361         case REQ_DOWN_FIELD:    /* FALLTHRU */
 362         case REQ_END_FIELD:     /* FALLTHRU */
 363         case REQ_END_LINE:      /* FALLTHRU */
 364         case REQ_FIRST_FIELD:   /* FALLTHRU */
 365         case REQ_FIRST_PAGE:    /* FALLTHRU */
 366         case REQ_LAST_FIELD:    /* FALLTHRU */
 367         case REQ_LAST_PAGE:     /* FALLTHRU */
 368         case REQ_LEFT_CHAR:     /* FALLTHRU */
 369         case REQ_LEFT_FIELD:    /* FALLTHRU */
 370         case REQ_NEXT_CHAR:     /* FALLTHRU */
 371         case REQ_NEXT_CHOICE:   /* FALLTHRU */
 372         case REQ_NEXT_FIELD:    /* FALLTHRU */
 373         case REQ_NEXT_LINE:     /* FALLTHRU */
 374         case REQ_NEXT_PAGE:     /* FALLTHRU */
 375         case REQ_NEXT_WORD:     /* FALLTHRU */
 376         case REQ_PREV_CHAR:     /* FALLTHRU */
 377         case REQ_PREV_CHOICE:   /* FALLTHRU */
 378         case REQ_PREV_FIELD:    /* FALLTHRU */
 379         case REQ_PREV_LINE:     /* FALLTHRU */
 380         case REQ_PREV_PAGE:     /* FALLTHRU */
 381         case REQ_PREV_WORD:     /* FALLTHRU */
 382         case REQ_RIGHT_CHAR:    /* FALLTHRU */
 383         case REQ_RIGHT_FIELD:   /* FALLTHRU */
 384         case REQ_SFIRST_FIELD:  /* FALLTHRU */
 385         case REQ_SLAST_FIELD:   /* FALLTHRU */
 386         case REQ_SNEXT_FIELD:   /* FALLTHRU */
 387         case REQ_SPREV_FIELD:   /* FALLTHRU */
 388         case REQ_UP_CHAR:       /* FALLTHRU */
 389         case REQ_UP_FIELD:      /* FALLTHRU */
 390         case REQ_VALIDATION:    /* FALLTHRU */
 391             modified = FALSE;
 392             break;
 393
 394         default:
 395             modified = FALSE;
 396             if (ch >= MIN_FORM_COMMAND) {
 397                 beep();
 398             } else if (isprint(ch)) {
 399                 modified = TRUE;
 400             }
 401             break;
 402         }
 403
 404         /*
 405          * If we do not force a re-validation, then field_buffer 0 will
 406          * be lagging by one character.
 407          */
 408         if (modified && form_driver(form, REQ_VALIDATION) == E_OK && *result
 409             < MIN_FORM_COMMAND)
 410             ++length;
 411
 412         set_buffer_length(before, length);
 413     }
 414
 415     if (current_field(form) != before)
 416         inactive_field(before);
 417     return status;
 418 }
 419
 420 void
 421 free_edit_field(FIELD *f)
 422 {
 423     FieldAttrs *ptr = field_attrs(f);
 424     if (ptr != 0) {
 425         free(ptr->row_lengths);
 426         free(ptr);
 427     }
 428 }
 429 #else
 430
 431 extern void no_edit_field(void);
 432
 433 void
 434 no_edit_field(void)
 435 {
 436 }
 437
 438 #endif