Home | History | Annotate | Line # | Download | only in libform
form.c revision 1.14 
      1 /*	$NetBSD: form.c,v 1.14 2003/03/09 00:57:18 lukem Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 1998-1999 Brett Lymn
      5  *                         (blymn (at) baea.com.au, brett_lymn (at) yahoo.com.au)
      6  * All rights reserved.
      7  *
      8  * This code has been donated to The NetBSD Foundation by the Author.
      9  *
     10  * Redistribution and use in source and binary forms, with or without
     11  * modification, are permitted provided that the following conditions
     12  * are met:
     13  * 1. Redistributions of source code must retain the above copyright
     14  *    notice, this list of conditions and the following disclaimer.
     15  * 2. The name of the author may not be used to endorse or promote products
     16  *    derived from this software without specific prior written permission
     17  *
     18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
     19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
     20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
     21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
     22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
     23  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
     27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     28  *
     29  *
     30  */
     31 
     32 #include <sys/cdefs.h>
     33 __RCSID("$NetBSD: form.c,v 1.14 2003/03/09 00:57:18 lukem Exp $");
     34 
     35 #include <stdlib.h>
     36 #include <strings.h>
     37 #include <form.h>
     38 #include "internals.h"
     39 
     40 extern FIELD _formi_default_field;
     41 
     42 FORM _formi_default_form = {
     43 	FALSE, /* true if performing a init or term function */
     44 	FALSE, /* the form is posted */
     45 	FALSE, /* make field list circular if true */
     46 	NULL, /* window for the form */
     47 	NULL, /* subwindow for the form */
     48 	NULL, /* use this window for output */
     49 	NULL, /* user defined pointer */
     50 	0, /* options for the form */
     51 	NULL, /* function called when form posted and
     52 				after page change */
     53 	NULL, /* function called when form is unposted and
     54 				before page change */
     55 	NULL, /* function called when form posted and after
     56 				 current field changes */
     57 	NULL, /* function called when form unposted and
     58 				 before current field changes */
     59 	0, /* number of fields attached */
     60 	0, /* current field */
     61 	0, /* current page of form */
     62 	0, /* number of pages in the form */
     63 	NULL, /* dynamic array of fields that start
     64 					   the pages */
     65 	{NULL, NULL}, /* sorted field list */
     66 	NULL /* array of fields attached to this form. */
     67 };
     68 
     69 /*
     70  * Set the window associated with the form
     71  */
     72 int
     73 set_form_win(FORM *form, WINDOW *win)
     74 {
     75 	if (form == NULL) {
     76 		_formi_default_form.win = win;
     77 		_formi_default_form.scrwin = win;
     78 	} else {
     79 		if (form->posted == TRUE)
     80 			return E_POSTED;
     81 		else {
     82 			form->win = win;
     83 			form->scrwin = win;
     84 		}
     85 	}
     86 
     87 	return E_OK;
     88 }
     89 
     90 /*
     91  * Return the window used by the given form
     92  */
     93 WINDOW *
     94 form_win(FORM *form)
     95 {
     96 	if (form == NULL)
     97 		return _formi_default_form.win;
     98 	else
     99 		return form->win;
    100 }
    101 
    102 /*
    103  * Set the subwindow for the form.
    104  */
    105 int
    106 set_form_sub(FORM *form, WINDOW *window)
    107 {
    108 	if (form == NULL) {
    109 		_formi_default_form.subwin = window;
    110 		_formi_default_form.scrwin = window;
    111 	} else {
    112 		if (form->posted == TRUE)
    113 			return E_POSTED;
    114 		else {
    115 			form->subwin = window;
    116 			form->scrwin = window;
    117 		}
    118 	}
    119 
    120 	return E_OK;
    121 }
    122 
    123 /*
    124  * Return the subwindow for the given form.
    125  */
    126 WINDOW *
    127 form_sub(FORM *form)
    128 {
    129 	if (form == NULL)
    130 		return _formi_default_form.subwin;
    131 	else
    132 		return form->subwin;
    133 }
    134 
    135 /*
    136  * Return the minimum size required to contain the form.
    137  */
    138 int
    139 scale_form(FORM *form, int *rows, int *cols)
    140 {
    141 	int i, max_row, max_col, temp;
    142 
    143 	if ((form->fields == NULL) || (form->fields[0] == NULL))
    144 		return E_NOT_CONNECTED;
    145 
    146 	max_row = 0;
    147 	max_col = 0;
    148 
    149 	for (i = 0; i < form->field_count; i++) {
    150 		temp = form->fields[i]->form_row + form->fields[i]->rows;
    151 		max_row = (temp > max_row)? temp : max_row;
    152 		temp = form->fields[i]->form_col + form->fields[i]->cols;
    153 		max_col = (temp > max_col)? temp : max_col;
    154 	}
    155 
    156 	(*rows) = max_row;
    157 	(*cols) = max_col;
    158 
    159 	return E_OK;
    160 }
    161 
    162 /*
    163  * Set the user defined pointer for the form given.
    164  */
    165 int
    166 set_form_userptr(FORM *form, void *ptr)
    167 {
    168 	if (form == NULL)
    169 		_formi_default_form.userptr = ptr;
    170 	else
    171 		form->userptr = ptr;
    172 
    173 	return E_OK;
    174 }
    175 
    176 /*
    177  * Return the user defined pointer associated with the given form.
    178  */
    179 void *
    180 form_userptr(FORM *form)
    181 {
    182 
    183 	if (form == NULL)
    184 		return _formi_default_form.userptr;
    185 	else
    186 		return form->userptr;
    187 }
    188 
    189 /*
    190  * Set the form options to the given ones.
    191  */
    192 int
    193 set_form_opts(FORM *form, Form_Options options)
    194 {
    195 	if (form == NULL)
    196 		_formi_default_form.opts = options;
    197 	else
    198 		form->opts = options;
    199 
    200 	return E_OK;
    201 }
    202 
    203 /*
    204  * Turn the given options on for the form.
    205  */
    206 int
    207 form_opts_on(FORM *form, Form_Options options)
    208 {
    209 	if (form == NULL)
    210 		_formi_default_form.opts |= options;
    211 	else
    212 		form->opts |= options;
    213 
    214 	return E_OK;
    215 }
    216 
    217 /*
    218  * Turn the given options off for the form.
    219  */
    220 int
    221 form_opts_off(FORM *form, Form_Options options)
    222 {
    223 	if (form == NULL)
    224 		_formi_default_form.opts &= ~options;
    225 	else
    226 		form->opts &= ~options;
    227 
    228 
    229 	return E_OK;
    230 }
    231 
    232 /*
    233  * Return the options set for the given form.
    234  */
    235 Form_Options
    236 form_opts(FORM *form)
    237 {
    238 	if (form == NULL)
    239 		return _formi_default_form.opts;
    240 	else
    241 		return form->opts;
    242 }
    243 
    244 /*
    245  * Set the form init function for the given form
    246  */
    247 int
    248 set_form_init(FORM *form, Form_Hook func)
    249 {
    250 	if (form == NULL)
    251 		_formi_default_form.form_init = func;
    252 	else
    253 		form->form_init = func;
    254 
    255 	return E_OK;
    256 }
    257 
    258 /*
    259  * Return the init function associated with the given form.
    260  */
    261 Form_Hook
    262 form_init(FORM *form)
    263 {
    264 	if (form == NULL)
    265 		return _formi_default_form.form_init;
    266 	else
    267 		return form->form_init;
    268 }
    269 
    270 /*
    271  * Set the function to be called on form termination.
    272  */
    273 int
    274 set_form_term(FORM *form, Form_Hook function)
    275 {
    276 	if (form == NULL)
    277 		_formi_default_form.form_term = function;
    278 	else
    279 		form->form_term = function;
    280 
    281 	return E_OK;
    282 }
    283 
    284 /*
    285  * Return the function defined for the termination function.
    286  */
    287 Form_Hook
    288 form_term(FORM *form)
    289 {
    290 
    291 	if (form == NULL)
    292 		return _formi_default_form.form_term;
    293 	else
    294 		return form->form_term;
    295 }
    296 
    297 
    298 /*
    299  * Attach the given fields to the form.
    300  */
    301 int
    302 set_form_fields(FORM *form, FIELD **fields)
    303 {
    304 	int num_fields = 0, i, maxpg = 1, status;
    305 
    306 	if (form == NULL)
    307 		return E_BAD_ARGUMENT;
    308 
    309 	if (form->posted == TRUE)
    310 		return E_POSTED;
    311 
    312 	if (fields == NULL)
    313 		return E_BAD_ARGUMENT;
    314 
    315 	while (fields[num_fields] != NULL) {
    316 		if ((fields[num_fields]->parent != NULL) &&
    317 		    (fields[num_fields]->parent != form))
    318 			return E_CONNECTED;
    319 		num_fields++;
    320 	}
    321 
    322 	  /* disconnect old fields, if any */
    323 	if (form->fields != NULL) {
    324 		for (i = 0; i < form->field_count; i++) {
    325 			form->fields[i]->parent = NULL;
    326 			form->fields[i]->index = -1;
    327 		}
    328 	}
    329 
    330 	  /* kill old page pointers if any */
    331 	if (form->page_starts != NULL)
    332 		free(form->page_starts);
    333 
    334 	form->field_count = num_fields;
    335 
    336 	  /* now connect the new fields to the form */
    337 	for (i = 0; i < num_fields; i++) {
    338 		fields[i]->parent = form;
    339 		fields[i]->index = i;
    340 		  /* set the page number of the field */
    341 		if (fields[i]->page_break == 1)
    342 			maxpg++;
    343 		fields[i]->page = maxpg;
    344 	}
    345 
    346 	form->fields = fields;
    347 	form->cur_field = 0;
    348 	form->max_page = maxpg;
    349 	if ((status = _formi_find_pages(form)) != E_OK)
    350 		return status;
    351 
    352 	  /* sort the fields and set the navigation pointers */
    353 	_formi_sort_fields(form);
    354 	_formi_stitch_fields(form);
    355 
    356 	return E_OK;
    357 }
    358 
    359 /*
    360  * Return the fields attached to the form given.
    361  */
    362 FIELD **
    363 form_fields(FORM *form)
    364 {
    365 	if (form == NULL)
    366 		return NULL;
    367 
    368 	return form->fields;
    369 }
    370 
    371 /*
    372  * Return the number of fields attached to the given form.
    373  */
    374 int
    375 field_count(FORM *form)
    376 {
    377 	if (form == NULL)
    378 		return -1;
    379 
    380 	return form->field_count;
    381 }
    382 
    383 /*
    384  * Move the given field to the row and column given.
    385  */
    386 int
    387 move_field(FIELD *fptr, int frow, int fcol)
    388 {
    389 	FIELD *field = (fptr == NULL) ? &_formi_default_field : fptr;
    390 
    391 	if (field->parent != NULL)
    392 		return E_CONNECTED;
    393 
    394 	field->form_row = frow;
    395 	field->form_col = fcol;
    396 
    397 	return E_OK;
    398 }
    399 
    400 /*
    401  * Set the page of the form to the given page.
    402  */
    403 int
    404 set_form_page(FORM *form, int page)
    405 {
    406 	if (form == NULL)
    407 		return E_BAD_ARGUMENT;
    408 
    409 	if (form->in_init == TRUE)
    410 		return E_BAD_STATE;
    411 
    412 	if (page > form->max_page)
    413 		return E_BAD_ARGUMENT;
    414 
    415 	form->page = page;
    416 	return E_OK;
    417 }
    418 
    419 /*
    420  * Return the maximum page of the form.
    421  */
    422 int
    423 form_max_page(FORM *form)
    424 {
    425 	if (form == NULL)
    426 		return _formi_default_form.max_page;
    427 	else
    428 		return form->max_page;
    429 }
    430 
    431 /*
    432  * Return the current page of the form.
    433  */
    434 int
    435 form_page(FORM *form)
    436 {
    437 	if (form == NULL)
    438 		return E_BAD_ARGUMENT;
    439 
    440 	return form->page;
    441 }
    442 
    443 /*
    444  * Set the current field to the field given.
    445  */
    446 int
    447 set_current_field(FORM *form, FIELD *field)
    448 {
    449 	if (form == NULL)
    450 		return E_BAD_ARGUMENT;
    451 
    452 	if (form->in_init == TRUE)
    453 		return E_BAD_STATE;
    454 
    455 	if (field == NULL)
    456 		return E_INVALID_FIELD;
    457 
    458 	if ((field->parent == NULL) || (field->parent != form))
    459 		return E_INVALID_FIELD; /* field is not of this form */
    460 
    461 	form->cur_field = field->index;
    462 
    463 	  /* XXX update page if posted??? */
    464 	return E_OK;
    465 }
    466 
    467 /*
    468  * Return the current field of the given form.
    469  */
    470 FIELD *
    471 current_field(FORM *form)
    472 {
    473 	if (form == NULL)
    474 		return NULL;
    475 
    476 	if (form->fields == NULL)
    477 		return NULL;
    478 
    479 	return form->fields[form->cur_field];
    480 }
    481 
    482 /*
    483  * Allocate a new form with the given fields.
    484  */
    485 FORM *
    486 new_form(FIELD **fields)
    487 {
    488 	FORM *new;
    489 
    490 	if ((new = (FORM *) malloc(sizeof(FORM))) == NULL)
    491 		return NULL;
    492 
    493 
    494 	  /* copy in the defaults... */
    495 	bcopy(&_formi_default_form, new, sizeof(FORM));
    496 
    497 	if (new->win == NULL)
    498 		new->scrwin = stdscr; /* something for curses to write to */
    499 
    500 	if (fields != NULL) { /* attach the fields, if any */
    501 		if (set_form_fields(new, fields) < 0) {
    502 			free(new); /* field attach failed, back out */
    503 			return NULL;
    504 		}
    505 	}
    506 
    507 	return new;
    508 }
    509 
    510 /*
    511  * Free the given form.
    512  */
    513 int
    514 free_form(FORM *form)
    515 {
    516 	int i;
    517 
    518 	if (form == NULL)
    519 		return E_BAD_ARGUMENT;
    520 
    521 	if (form->posted == TRUE)
    522 		return E_POSTED;
    523 
    524 	for (i = 0; i < form->field_count; i++) {
    525 		  /* detach all the fields from the form */
    526 		form->fields[i]->parent = NULL;
    527 		form->fields[i]->index = -1;
    528 	}
    529 
    530 	free(form);
    531 
    532 	return E_OK;
    533 }
    534 
    535 /*
    536  * Tell if the current field of the form has offscreen data ahead
    537  */
    538 int
    539 data_ahead(FORM *form)
    540 {
    541 	FIELD *cur;
    542 
    543 	if ((form == NULL) || (form->fields == NULL)
    544 	    || (form->fields[0] == NULL))
    545 		return FALSE;
    546 
    547 	cur = form->fields[form->cur_field];
    548 
    549 	  /*XXXX wrong */
    550 	if (cur->lines[cur->start_line + cur->cursor_ypos].length > cur->cols)
    551 		return TRUE;
    552 
    553 	return FALSE;
    554 }
    555 
    556 /*
    557  * Tell if current field of the form has offscreen data behind
    558  */
    559 int
    560 data_behind(FORM *form)
    561 {
    562 	FIELD *cur;
    563 
    564 	if ((form == NULL) || (form->fields == NULL)
    565 	    || (form->fields[0] == NULL))
    566 		return FALSE;
    567 
    568 	cur = form->fields[form->cur_field];
    569 
    570 	if (cur->start_char > 0)
    571 		return TRUE;
    572 
    573 	return FALSE;
    574 }
    575 
    576 /*
    577  * Position the form cursor.
    578  */
    579 int
    580 pos_form_cursor(FORM *form)
    581 {
    582 	FIELD *cur;
    583 	int row, col;
    584 
    585 	if ((form == NULL) || (form->fields == NULL) ||
    586 	    (form->fields[0] == NULL))
    587 		return E_BAD_ARGUMENT;
    588 
    589 	if (form->posted != 1)
    590 		return E_NOT_POSTED;
    591 
    592 	cur = form->fields[form->cur_field];
    593 	row = cur->form_row;
    594 	col = cur->form_col;
    595 
    596 	  /* if the field is public then show the cursor pos */
    597 	if ((cur->opts & O_PUBLIC) == O_PUBLIC) {
    598 		row += cur->cursor_ypos;
    599 		col += cur->cursor_xpos;
    600 		if (cur->cursor_xpos >= cur->cols) {
    601 			col = cur->form_col;
    602 			row++;
    603 		}
    604 	}
    605 
    606 #ifdef DEBUG
    607 	fprintf(dbg, "pos_cursor: row=%d, col=%d\n", row, col);
    608 #endif
    609 
    610 	wmove(form->scrwin, row, col);
    611 
    612 	return E_OK;
    613 }
    614