1 /* $NetBSD: field.c,v 1.29 2015/09/07 15:50:49 joerg Exp $ */
2 /*-
3 * Copyright (c) 1998-1999 Brett Lymn
4 * (blymn@baea.com.au, brett_lymn@yahoo.com.au)
5 * All rights reserved.
6 *
7 * This code has been donated to The NetBSD Foundation by the Author.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 *
29 */
30
31 #include <sys/cdefs.h>
32 __RCSID("$NetBSD: field.c,v 1.29 2015/09/07 15:50:49 joerg Exp $");
33
34 #include <sys/param.h>
35 #include <stdlib.h>
36 #include <strings.h>
37 #include <stdarg.h>
38 #include <form.h>
39 #include "internals.h"
40
41 extern FORM _formi_default_form;
42
43 FIELD _formi_default_field = {
44 0, /* rows in the field */
45 0, /* columns in the field */
46 0, /* dynamic rows */
47 0, /* dynamic columns */
48 0, /* maximum growth */
49 0, /* starting row in the form subwindow */
50 0, /* starting column in the form subwindow */
51 0, /* number of off screen rows */
52 0, /* index of this field in form fields array. */
53 0, /* number of buffers associated with this field */
54 FALSE, /* set to true if buffer 0 has changed. */
55 NO_JUSTIFICATION, /* justification style of the field */
56 FALSE, /* set to true if field is in overlay mode */
57 NULL, /* pointer to the current line cursor is on */
58 0, /* starting char in string (horiz scroll) */
59 NULL, /* starting line in field (vert scroll) */
60 0, /* number of rows actually used in field */
61 0, /* actual pos of cursor in row, not same as x pos due to tabs */
62 0, /* x pos of cursor in field */
63 0, /* y pos of cursor in field */
64 0, /* start of a new page on the form if 1 */
65 0, /* number of the page this field is on */
66 A_NORMAL, /* character attributes for the foreground */
67 A_NORMAL, /* character attributes for the background */
68 ' ', /* padding character */
69 DEFAULT_FORM_OPTS, /* options for the field */
70 NULL, /* the form this field is bound to, if any */
71 NULL, /* field above this one */
72 NULL, /* field below this one */
73 NULL, /* field to the left of this one */
74 NULL, /* field to the right of this one */
75 NULL, /* user defined pointer. */
76 NULL, /* used if fields are linked */
77 NULL, /* type struct for the field */
78 {NULL, NULL}, /* circle queue glue for sorting fields */
79 NULL, /* args for field type. */
80 NULL, /* pointer to the array of lines structures. */
81 NULL, /* list of lines available for reuse */
82 NULL, /* array of buffers for the field */
83 };
84
85 /* internal function prototypes */
86 static int
87 field_buffer_init(FIELD *field, int buffer, unsigned int len);
88 static FIELD *
89 _formi_create_field(FIELD *, int, int, int, int, int, int);
90
91
92 /*
93 * Set the userptr for the field
94 */
95 int
set_field_userptr(FIELD * field,void * ptr)96 set_field_userptr(FIELD *field, void *ptr)
97 {
98 FIELD *fp = (field == NULL) ? &_formi_default_field : field;
99
100 fp->userptr = ptr;
101
102 return E_OK;
103 }
104
105 /*
106 * Return the userptr for the field.
107 */
108
109 void *
field_userptr(FIELD * field)110 field_userptr(FIELD *field)
111 {
112 if (field == NULL)
113 return _formi_default_field.userptr;
114 else
115 return field->userptr;
116 }
117
118 /*
119 * Set the options for the designated field.
120 */
121 int
set_field_opts(FIELD * field,Form_Options options)122 set_field_opts(FIELD *field, Form_Options options)
123 {
124 int i;
125
126 FIELD *fp = (field == NULL) ? &_formi_default_field : field;
127
128 /* not allowed to set opts if the field is the current one */
129 if ((field != NULL) && (field->parent != NULL) &&
130 (field->parent->cur_field == field->index))
131 return E_CURRENT;
132
133 if ((options & O_STATIC) == O_STATIC) {
134 for (i = 0; i < fp->nbuf; i++) {
135 if (fp->buffers[i].length > fp->cols)
136 fp->buffers[i].string[fp->cols] = '\0';
137 }
138 }
139
140 fp->opts = options;
141
142 /* if appropriate, redraw the field */
143 if ((field != NULL) && (field->parent != NULL)
144 && (field->parent->posted == 1)) {
145 _formi_redraw_field(field->parent, field->index);
146 pos_form_cursor(field->parent);
147 wrefresh(field->parent->scrwin);
148 }
149
150 return E_OK;
151 }
152
153 /*
154 * Turn on the passed field options.
155 */
156 int
field_opts_on(FIELD * field,Form_Options options)157 field_opts_on(FIELD *field, Form_Options options)
158 {
159 int i;
160
161 FIELD *fp = (field == NULL) ? &_formi_default_field : field;
162
163 /* not allowed to set opts if the field is the current one */
164 if ((field != NULL) && (field->parent != NULL) &&
165 (field->parent->cur_field == field->index))
166 return E_CURRENT;
167
168 if ((options & O_STATIC) == O_STATIC) {
169 for (i = 0; i < fp->nbuf; i++) {
170 if (fp->buffers[i].length > fp->cols)
171 fp->buffers[i].string[fp->cols] = '\0';
172 }
173 }
174
175 fp->opts |= options;
176
177 /* if appropriate, redraw the field */
178 if ((field != NULL) && (field->parent != NULL)
179 && (field->parent->posted == 1)) {
180 _formi_redraw_field(field->parent, field->index);
181 pos_form_cursor(field->parent);
182 wrefresh(field->parent->scrwin);
183 }
184
185 return E_OK;
186 }
187
188 /*
189 * Turn off the passed field options.
190 */
191 int
field_opts_off(FIELD * field,Form_Options options)192 field_opts_off(FIELD *field, Form_Options options)
193 {
194 FIELD *fp = (field == NULL) ? &_formi_default_field : field;
195
196 /* not allowed to set opts if the field is the current one */
197 if ((field != NULL) && (field->parent != NULL) &&
198 (field->parent->cur_field == field->index))
199 return E_CURRENT;
200
201 fp->opts &= ~options;
202
203 /* if appropriate, redraw the field */
204 if ((field != NULL) && (field->parent != NULL)
205 && (field->parent->posted == 1)) {
206 _formi_redraw_field(field->parent, field->index);
207 pos_form_cursor(field->parent);
208 wrefresh(field->parent->scrwin);
209 }
210
211 return E_OK;
212 }
213
214 /*
215 * Return the field options associated with the passed field.
216 */
217 Form_Options
field_opts(FIELD * field)218 field_opts(FIELD *field)
219 {
220 if (field == NULL)
221 return _formi_default_field.opts;
222 else
223 return field->opts;
224 }
225
226 /*
227 * Set the justification for the passed field.
228 */
229 int
set_field_just(FIELD * field,int justification)230 set_field_just(FIELD *field, int justification)
231 {
232 FIELD *fp = (field == NULL) ? &_formi_default_field : field;
233
234 /*
235 * not allowed to set justification if the field is
236 * the current one
237 */
238 if ((field != NULL) && (field->parent != NULL) &&
239 (field->parent->cur_field == field->index))
240 return E_CURRENT;
241
242 if ((justification < MIN_JUST_STYLE) /* check justification valid */
243 || (justification > MAX_JUST_STYLE))
244 return E_BAD_ARGUMENT;
245
246 /* only allow justification on static, single row fields */
247 if (((fp->opts & O_STATIC) != O_STATIC) ||
248 ((fp->rows + fp->nrows) > 1))
249 return E_BAD_ARGUMENT;
250
251 fp->justification = justification;
252
253 _formi_init_field_xpos(fp);
254
255 return E_OK;
256 }
257
258 /*
259 * Return the justification style of the field passed.
260 */
261 int
field_just(FIELD * field)262 field_just(FIELD *field)
263 {
264 if (field == NULL)
265 return _formi_default_field.justification;
266 else
267 return field->justification;
268 }
269
270 /*
271 * Return information about the field passed.
272 */
273 int
field_info(FIELD * field,int * rows,int * cols,int * frow,int * fcol,int * nrow,int * nbuf)274 field_info(FIELD *field, int *rows, int *cols, int *frow, int *fcol,
275 int *nrow, int *nbuf)
276 {
277 if (field == NULL)
278 return E_BAD_ARGUMENT;
279
280 *rows = field->rows;
281 *cols = field->cols;
282 *frow = field->form_row;
283 *fcol = field->form_col;
284 *nrow = field->nrows;
285 *nbuf = field->nbuf;
286
287 return E_OK;
288 }
289
290 /*
291 * Report the dynamic field information.
292 */
293 int
dynamic_field_info(FIELD * field,int * drows,int * dcols,int * max)294 dynamic_field_info(FIELD *field, int *drows, int *dcols, int *max)
295 {
296 if (field == NULL)
297 return E_BAD_ARGUMENT;
298
299 if ((field->opts & O_STATIC) == O_STATIC) {
300 *drows = field->rows;
301 *dcols = field->cols;
302 } else {
303 *drows = field->drows;
304 *dcols = field->dcols;
305 }
306
307 *max = field->max;
308
309 return E_OK;
310 }
311
312 /*
313 * Init all the field variables, perform wrapping and other tasks
314 * after the field buffer is set.
315 */
316 static int
field_buffer_init(FIELD * field,int buffer,unsigned int len)317 field_buffer_init(FIELD *field, int buffer, unsigned int len)
318 {
319 int status;
320 char *newp;
321
322 if (buffer == 0) {
323 field->start_char = 0;
324 field->start_line = 0;
325 field->row_xpos = 0;
326 field->cursor_xpos = 0;
327 field->cursor_ypos = 0;
328 field->row_count = 1; /* must be at least one row XXX need to shift old rows (if any) to free list??? */
329 field->alines->length = len;
330 if ((newp = realloc(field->alines->string,
331 (size_t) len + 1)) == NULL)
332 return E_SYSTEM_ERROR;
333 field->alines->string = newp;
334 field->alines->allocated = len + 1;
335 strlcpy(field->alines->string, field->buffers[buffer].string,
336 (size_t) len + 1);
337 field->alines->expanded =
338 _formi_tab_expanded_length(field->alines->string,
339 0, field->alines->length);
340
341 field->start_line = field->alines;
342 field->cur_line = field->alines;
343
344 /* we have to hope the wrap works - if it does not then the
345 buffer is pretty much borked */
346 status = _formi_wrap_field(field, field->cur_line);
347 if (status != E_OK)
348 return status;
349
350 /*
351 * calculate the tabs for a single row field, the
352 * multiline case is handled when the wrap is done.
353 */
354 if (field->row_count == 1)
355 _formi_calculate_tabs(field->alines);
356
357 /* redraw the field to reflect the new contents. If the field
358 * is attached....
359 */
360 if ((field->parent != NULL) && (field->parent->posted == 1)) {
361 _formi_redraw_field(field->parent, field->index);
362 /* make sure cursor goes back to current field */
363 pos_form_cursor(field->parent);
364 }
365 }
366
367 return E_OK;
368 }
369
370
371 /*
372 * Set the field buffer to the string that results from processing
373 * the given format (fmt) using sprintf.
374 */
375 int
set_field_printf(FIELD * field,int buffer,char * fmt,...)376 set_field_printf(FIELD *field, int buffer, char *fmt, ...)
377 {
378 int len;
379 va_list args;
380
381 if (field == NULL)
382 return E_BAD_ARGUMENT;
383
384 if (buffer >= field->nbuf)
385 return E_BAD_ARGUMENT;
386
387 va_start(args, fmt);
388 /* check for buffer already existing, free the storage */
389 if (field->buffers[buffer].allocated != 0)
390 free(field->buffers[buffer].string);
391
392 len = vasprintf(&field->buffers[buffer].string, fmt, args);
393 va_end(args);
394 if (len < 0)
395 return E_SYSTEM_ERROR;
396
397 field->buffers[buffer].length = len;
398 field->buffers[buffer].allocated = len + 1;
399 if (((field->opts & O_STATIC) == O_STATIC) && (len > field->cols)
400 && ((field->rows + field->nrows) == 1))
401 len = field->cols;
402
403 field->buffers[buffer].string[len] = '\0';
404 return field_buffer_init(field, buffer, (unsigned int) len);
405 }
406
407 /*
408 * Set the value of the field buffer to the value given.
409 */
410
411 int
set_field_buffer(FIELD * field,int buffer,const char * value)412 set_field_buffer(FIELD *field, int buffer, const char *value)
413 {
414 unsigned int len;
415 int status;
416
417 if (field == NULL)
418 return E_BAD_ARGUMENT;
419
420 if (buffer >= field->nbuf) /* make sure buffer is valid */
421 return E_BAD_ARGUMENT;
422
423 len = (unsigned int) strlen(value);
424 if (((field->opts & O_STATIC) == O_STATIC) && (len > field->cols)
425 && ((field->rows + field->nrows) == 1))
426 len = field->cols;
427
428 #ifdef DEBUG
429 if (_formi_create_dbg_file() != E_OK)
430 return E_SYSTEM_ERROR;
431
432 fprintf(dbg,
433 "set_field_buffer: entry: len = %d, value = %s, buffer=%d\n",
434 len, value, buffer);
435 fprintf(dbg, "set_field_buffer: entry: string = ");
436 if (field->buffers[buffer].string != NULL)
437 fprintf(dbg, "%s, len = %d\n", field->buffers[buffer].string,
438 field->buffers[buffer].length);
439 else
440 fprintf(dbg, "(null), len = 0\n");
441 fprintf(dbg, "set_field_buffer: entry: lines.len = %d\n",
442 field->alines[0].length);
443 #endif
444
445 if ((field->buffers[buffer].string =
446 (char *) realloc(field->buffers[buffer].string,
447 (size_t) len + 1)) == NULL)
448 return E_SYSTEM_ERROR;
449
450 strlcpy(field->buffers[buffer].string, value, (size_t) len + 1);
451 field->buffers[buffer].length = len;
452 field->buffers[buffer].allocated = len + 1;
453 status = field_buffer_init(field, buffer, len);
454
455 #ifdef DEBUG
456 fprintf(dbg, "set_field_buffer: exit: len = %d, value = %s\n",
457 len, value);
458 fprintf(dbg, "set_field_buffer: exit: string = %s, len = %d\n",
459 field->buffers[buffer].string, field->buffers[buffer].length);
460 fprintf(dbg, "set_field_buffer: exit: lines.len = %d\n",
461 field->alines[0].length);
462 #endif
463
464 return status;
465 }
466
467 /*
468 * Return the requested field buffer to the caller.
469 */
470 char *
field_buffer(FIELD * field,int buffer)471 field_buffer(FIELD *field, int buffer)
472 {
473
474 char *reformat, *p;
475 _FORMI_FIELD_LINES *linep;
476 size_t bufsize, pos;
477
478 if (field == NULL)
479 return NULL;
480
481 if (buffer >= field->nbuf)
482 return NULL;
483
484 /*
485 * We force a sync from the line structs to the buffer here.
486 * Traditional libform say we don't need to because it is
487 * done on a REQ_VALIDATE but NetBSD libform previously did
488 * not enforce this because the buffer contents were always
489 * current. Changes to line handling make this no longer so
490 * - the line structs may contain different data to the
491 * buffer if unsynced.
492 */
493 if (_formi_sync_buffer(field) != E_OK)
494 return NULL;
495
496 if ((field->opts & O_REFORMAT) != O_REFORMAT)
497 return field->buffers[buffer].string;
498
499 if (field->row_count <= 1)
500 return strdup(field->buffers[buffer].string);
501
502 /*
503 * create a single string containing each line,
504 * separated by newline, last line having no
505 * newline, but NUL terminated.
506 */
507 bufsize = pos = 0;
508 reformat = NULL;
509 for (linep = field->alines; linep; linep = linep->next) {
510 size_t len = strlen(linep->string);
511 if (len + 1 >= bufsize - pos) {
512 bufsize += MAX(1024, 2 * len);
513 p = realloc(reformat, bufsize);
514 if (p == NULL) {
515 free(reformat);
516 return NULL;
517 }
518 reformat = p;
519 }
520 memcpy(reformat + pos, linep->string, len);
521 pos += len;
522 reformat[pos++] = linep->next ? '\n' : '\0';
523 }
524 return reformat;
525 }
526
527 /*
528 * Set the buffer 0 field status.
529 */
530 int
set_field_status(FIELD * field,int status)531 set_field_status(FIELD *field, int status)
532 {
533
534 if (field == NULL)
535 return E_BAD_ARGUMENT;
536
537 if (status != FALSE)
538 field->buf0_status = TRUE;
539 else
540 field->buf0_status = FALSE;
541
542 return E_OK;
543 }
544
545 /*
546 * Return the buffer 0 status flag for the given field.
547 */
548 int
field_status(FIELD * field)549 field_status(FIELD *field)
550 {
551
552 if (field == NULL) /* the default buffer 0 never changes :-) */
553 return FALSE;
554
555 return field->buf0_status;
556 }
557
558 /*
559 * Set the maximum growth for a dynamic field.
560 */
561 int
set_max_field(FIELD * fptr,int max)562 set_max_field(FIELD *fptr, int max)
563 {
564 FIELD *field = (fptr == NULL)? &_formi_default_field : fptr;
565
566 if ((field->opts & O_STATIC) == O_STATIC) /* check if field dynamic */
567 return E_BAD_ARGUMENT;
568
569 if (max < 0) /* negative numbers are bad.... */
570 return E_BAD_ARGUMENT;
571
572 field->max = max;
573 return E_OK;
574 }
575
576 /*
577 * Set the field foreground character attributes.
578 */
579 int
set_field_fore(FIELD * fptr,chtype attribute)580 set_field_fore(FIELD *fptr, chtype attribute)
581 {
582 FIELD *field = (fptr == NULL)? &_formi_default_field : fptr;
583
584 field->fore = attribute;
585 return E_OK;
586 }
587
588 /*
589 * Return the foreground character attribute for the given field.
590 */
591 chtype
field_fore(FIELD * field)592 field_fore(FIELD *field)
593 {
594 if (field == NULL)
595 return _formi_default_field.fore;
596 else
597 return field->fore;
598 }
599
600 /*
601 * Set the background character attribute for the given field.
602 */
603 int
set_field_back(FIELD * field,chtype attribute)604 set_field_back(FIELD *field, chtype attribute)
605 {
606 if (field == NULL)
607 _formi_default_field.back = attribute;
608 else
609 field->back = attribute;
610
611 return E_OK;
612 }
613
614 /*
615 * Get the background character attribute for the given field.
616 */
617 chtype
field_back(FIELD * field)618 field_back(FIELD *field)
619 {
620 if (field == NULL)
621 return _formi_default_field.back;
622 else
623 return field->back;
624 }
625
626 /*
627 * Set the pad character for the given field.
628 */
629 int
set_field_pad(FIELD * field,int pad)630 set_field_pad(FIELD *field, int pad)
631 {
632 if (field == NULL)
633 _formi_default_field.pad = pad;
634 else
635 field->pad = pad;
636
637 return E_OK;
638 }
639
640 /*
641 * Return the padding character for the given field.
642 */
643 int
field_pad(FIELD * field)644 field_pad(FIELD *field)
645 {
646 if (field == NULL)
647 return _formi_default_field.pad;
648 else
649 return field->pad;
650 }
651
652 /*
653 * Set the field initialisation function hook.
654 */
655 int
set_field_init(FORM * form,Form_Hook function)656 set_field_init(FORM *form, Form_Hook function)
657 {
658 if (form == NULL)
659 _formi_default_form.field_init = function;
660 else
661 form->field_init = function;
662
663 return E_OK;
664 }
665
666 /*
667 * Return the function hook for the field initialisation.
668 */
669 Form_Hook
field_init(FORM * form)670 field_init(FORM *form)
671 {
672 if (form == NULL)
673 return _formi_default_form.field_init;
674 else
675 return form->field_init;
676 }
677
678 /*
679 * Set the field termination function hook.
680 */
681 int
set_field_term(FORM * form,Form_Hook function)682 set_field_term(FORM *form, Form_Hook function)
683 {
684 if (form == NULL)
685 _formi_default_form.field_term = function;
686 else
687 form->field_term = function;
688
689 return E_OK;
690 }
691
692 /*
693 * Return the function hook defined for the field termination.
694 */
695 Form_Hook
field_term(FORM * form)696 field_term(FORM *form)
697 {
698 if (form == NULL)
699 return _formi_default_form.field_term;
700 else
701 return form->field_term;
702 }
703
704 /*
705 * Set the page flag on the given field to indicate it is the start of a
706 * new page.
707 */
708 int
set_new_page(FIELD * fptr,int page)709 set_new_page(FIELD *fptr, int page)
710 {
711 FIELD *field = (fptr == NULL)? &_formi_default_field : fptr;
712
713 if (field->parent != NULL) /* check if field is connected to a form */
714 return E_CONNECTED;
715
716 field->page_break = (page != FALSE);
717 return E_OK;
718 }
719
720 /*
721 * Return the page status for the given field. TRUE is returned if the
722 * field is the start of a new page.
723 */
724 int
new_page(FIELD * field)725 new_page(FIELD *field)
726 {
727 if (field == NULL)
728 return _formi_default_field.page_break;
729 else
730 return field->page_break;
731 }
732
733 /*
734 * Return the index of the field in the form fields array.
735 */
736 int
field_index(FIELD * field)737 field_index(FIELD *field)
738 {
739 if (field == NULL)
740 return E_BAD_ARGUMENT;
741
742 if (field->parent == NULL)
743 return E_NOT_CONNECTED;
744
745 return field->index;
746 }
747
748 /*
749 * Internal function that does most of the work to create a new field.
750 * The new field is initialised from the information in the prototype
751 * field passed.
752 * Returns NULL on error.
753 */
754 static FIELD *
_formi_create_field(FIELD * prototype,int rows,int cols,int frow,int fcol,int nrows,int nbuf)755 _formi_create_field(FIELD *prototype, int rows, int cols, int frow,
756 int fcol, int nrows, int nbuf)
757 {
758 FIELD *new;
759
760 if ((rows <= 0) || (cols <= 0) || (frow < 0) || (fcol < 0) ||
761 (nrows < 0) || (nbuf < 0))
762 return NULL;
763
764 if ((new = (FIELD *)malloc(sizeof(FIELD))) == NULL) {
765 return NULL;
766 }
767
768 /* copy in the default field info */
769 bcopy(prototype, new, sizeof(FIELD));
770
771 new->nbuf = nbuf + 1;
772 new->rows = rows;
773 new->cols = cols;
774 new->form_row = frow;
775 new->form_col = fcol;
776 new->nrows = nrows;
777 new->link = new;
778 return new;
779 }
780
781 /*
782 * Create a new field structure.
783 */
784 FIELD *
new_field(int rows,int cols,int frow,int fcol,int nrows,int nbuf)785 new_field(int rows, int cols, int frow, int fcol, int nrows, int nbuf)
786 {
787 FIELD *new;
788 size_t buf_len;
789 int i;
790
791
792 if ((new = _formi_create_field(&_formi_default_field, rows, cols,
793 frow, fcol, nrows, nbuf)) == NULL)
794 return NULL;
795
796 buf_len = (nbuf + 1) * sizeof(FORM_STR);
797
798 if ((new->buffers = (FORM_STR *)malloc(buf_len)) == NULL) {
799 free(new);
800 return NULL;
801 }
802
803 /* Initialise the strings to a zero length string */
804 for (i = 0; i < nbuf + 1; i++) {
805 if ((new->buffers[i].string =
806 (char *) malloc(sizeof(char))) == NULL) {
807 free(new->buffers);
808 free(new);
809 return NULL;
810 }
811 new->buffers[i].string[0] = '\0';
812 new->buffers[i].length = 0;
813 new->buffers[i].allocated = 1;
814 }
815
816 if ((new->alines = (_FORMI_FIELD_LINES *)
817 malloc(sizeof(struct _formi_field_lines))) == NULL) {
818 free(new->buffers);
819 free(new);
820 return NULL;
821 }
822
823 new->alines->prev = NULL;
824 new->alines->next = NULL;
825 new->alines->allocated = 0;
826 new->alines->length = 0;
827 new->alines->expanded = 0;
828 new->alines->string = NULL;
829 new->alines->hard_ret = FALSE;
830 new->alines->tabs = NULL;
831 new->start_line = new->alines;
832 new->cur_line = new->alines;
833
834 return new;
835 }
836
837 /*
838 * Duplicate the given field, including its buffers.
839 */
840 FIELD *
dup_field(FIELD * field,int frow,int fcol)841 dup_field(FIELD *field, int frow, int fcol)
842 {
843 FIELD *new;
844 size_t row_len, buf_len;
845
846 if (field == NULL)
847 return NULL;
848
849 /* XXXX this right???? */
850 if ((new = _formi_create_field(field, (int) field->rows,
851 (int ) field->cols,
852 frow, fcol, (int) field->nrows,
853 field->nbuf - 1)) == NULL)
854 return NULL;
855
856 row_len = (field->rows + field->nrows + 1) * field->cols;
857 buf_len = (field->nbuf + 1) * row_len * sizeof(FORM_STR);
858
859 if ((new->buffers = (FORM_STR *)malloc(buf_len)) == NULL) {
860 free(new);
861 return NULL;
862 }
863
864 /* copy the buffers from the source field into the new copy */
865 bcopy(field->buffers, new->buffers, buf_len);
866
867 return new;
868 }
869
870 /*
871 * Create a new field at the specified location by duplicating the given
872 * field. The buffers are shared with the parent field.
873 */
874 FIELD *
link_field(FIELD * field,int frow,int fcol)875 link_field(FIELD *field, int frow, int fcol)
876 {
877 FIELD *new;
878
879 if (field == NULL)
880 return NULL;
881
882 if ((new = _formi_create_field(field, (int) field->rows,
883 (int) field->cols,
884 frow, fcol, (int) field->nrows,
885 field->nbuf - 1)) == NULL)
886 return NULL;
887
888 new->link = field->link;
889 field->link = new;
890
891 /* we are done. The buffer pointer was copied during the field
892 creation. */
893 return new;
894 }
895
896 /*
897 * Release all storage allocated to the field
898 */
899 int
free_field(FIELD * field)900 free_field(FIELD *field)
901 {
902 FIELD *flink;
903 int i;
904 _formi_tab_t *ts, *nts;
905
906 if (field == NULL)
907 return E_BAD_ARGUMENT;
908
909 if (field->parent != NULL)
910 return E_CONNECTED;
911
912 if (field->link == field) { /* check if field linked */
913 /* no it is not - release the buffers */
914 free(field->buffers);
915 /* free the tab structures */
916 for (i = 0; i < field->row_count - 1; i++) {
917 if (field->alines[i].tabs != NULL) {
918 ts = field->alines[i].tabs;
919 while (ts != NULL) {
920 nts = ts->fwd;
921 free(ts);
922 ts = nts;
923 }
924 }
925 }
926 } else {
927 /* is linked, traverse the links to find the field referring
928 * to the one to be freed.
929 */
930 for (flink = field->link; flink != field; flink = flink->link);
931 flink->link = field->link;
932 }
933
934 free(field);
935 return E_OK;
936 }
937
938
939