1 /* $NetBSD: driver.c,v 1.18 2013/11/26 01:17:00 christos 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: driver.c,v 1.18 2013/11/26 01:17:00 christos Exp $"); 34 35 #include <ctype.h> 36 #include "form.h" 37 #include "internals.h" 38 39 static int 40 traverse_form_links(FORM *form, int direction); 41 42 /* 43 * Traverse the links of the current field in the given direction until 44 * either a active & visible field is found or we return to the current 45 * field. Direction is the REQ_{LEFT,RIGHT,UP,DOWN}_FIELD driver commands. 46 * The function returns E_OK if a valid field is found, E_REQUEST_DENIED 47 * otherwise. 48 */ 49 static int 50 traverse_form_links(FORM *form, int direction) 51 { 52 unsigned idx; 53 54 idx = form->cur_field; 55 56 do { 57 switch (direction) { 58 case REQ_LEFT_FIELD: 59 if (form->fields[idx]->left == NULL) 60 return E_REQUEST_DENIED; 61 idx = form->fields[idx]->left->index; 62 break; 63 64 case REQ_RIGHT_FIELD: 65 if (form->fields[idx]->right == NULL) 66 return E_REQUEST_DENIED; 67 idx = form->fields[idx]->right->index; 68 break; 69 70 case REQ_UP_FIELD: 71 if (form->fields[idx]->up == NULL) 72 return E_REQUEST_DENIED; 73 idx = form->fields[idx]->up->index; 74 break; 75 76 case REQ_DOWN_FIELD: 77 if (form->fields[idx]->down == NULL) 78 return E_REQUEST_DENIED; 79 idx = form->fields[idx]->down->index; 80 break; 81 82 default: 83 return E_REQUEST_DENIED; 84 } 85 86 if ((form->fields[idx]->opts & (O_ACTIVE | O_VISIBLE)) 87 == (O_ACTIVE | O_VISIBLE)) { 88 form->cur_field = idx; 89 return E_OK; 90 } 91 } while (idx != form->cur_field); 92 93 return E_REQUEST_DENIED; 94 } 95 96 int 97 form_driver(FORM *form, int c) 98 { 99 FIELD *fieldp; 100 int update_page, update_field, old_field, old_page, status; 101 int start_field; 102 unsigned int pos; 103 104 if (form == NULL) 105 return E_BAD_ARGUMENT; 106 107 if ((form->fields == NULL) || (*(form->fields) == NULL)) 108 return E_INVALID_FIELD; 109 110 if (form->posted != 1) 111 return E_NOT_POSTED; 112 113 if (form->in_init == 1) 114 return E_BAD_STATE; 115 116 117 old_field = start_field = form->cur_field; 118 fieldp = form->fields[form->cur_field]; 119 update_page = update_field = 0; 120 status = E_OK; 121 122 if (c < REQ_MIN_REQUEST) { 123 if (isprint(c) || isblank(c)) { 124 do { 125 pos = fieldp->start_char + fieldp->row_xpos; 126 127 /* check if we are allowed to edit this field */ 128 if ((fieldp->opts & O_EDIT) != O_EDIT) 129 return E_REQUEST_DENIED; 130 131 if ((status = 132 (_formi_add_char(fieldp, pos, c))) 133 == E_REQUEST_DENIED) { 134 135 /* 136 * Need to check here if we 137 * want to autoskip. we 138 * call the form driver 139 * recursively to pos us on 140 * the next field and then 141 * we loop back to ensure 142 * the next field selected 143 * can have data added to it 144 */ 145 if ((fieldp->opts & O_AUTOSKIP) 146 != O_AUTOSKIP) 147 return E_REQUEST_DENIED; 148 status = form_driver(form, 149 REQ_NEXT_FIELD); 150 if (status != E_OK) 151 return status; 152 153 /* 154 * check if we have looped 155 * around all the fields. 156 * This can easily happen if 157 * all the fields are full. 158 */ 159 if (start_field == form->cur_field) 160 return E_REQUEST_DENIED; 161 162 old_field = form->cur_field; 163 fieldp = form->fields[form->cur_field]; 164 status = _formi_add_char(fieldp, 165 fieldp->start_char 166 + fieldp->cursor_xpos, 167 c); 168 } else if (status == E_INVALID_FIELD) 169 /* char failed validation, just 170 * return the status. 171 */ 172 return status; 173 else if (status == E_NO_ROOM) 174 /* we will get this if the line 175 * wrapping fails. Deny the 176 * request. 177 */ 178 return E_REQUEST_DENIED; 179 } 180 while (status != E_OK); 181 update_field = (status == E_OK); 182 } else 183 return E_REQUEST_DENIED; 184 } else { 185 if (c > REQ_MAX_COMMAND) 186 return E_UNKNOWN_COMMAND; 187 188 if ((c >= REQ_NEXT_PAGE) && (c <= REQ_DOWN_FIELD)) { 189 /* first check the field we are in is ok */ 190 if (_formi_validate_field(form) != E_OK) 191 return E_INVALID_FIELD; 192 193 if (form->field_term != NULL) 194 form->field_term(form); 195 196 /* 197 * if we have a page movement then the form term 198 * needs to be called too 199 */ 200 if ((c <= REQ_LAST_PAGE) && (form->form_term != NULL)) 201 form->form_term(form); 202 } 203 204 205 switch (c) { 206 case REQ_NEXT_PAGE: 207 if (form->page < form->max_page) { 208 old_page = form->page; 209 form->page++; 210 update_page = 1; 211 if (_formi_pos_first_field(form) != E_OK) { 212 form->page = old_page; 213 status = E_REQUEST_DENIED; 214 } 215 } else 216 status = E_REQUEST_DENIED; 217 break; 218 219 case REQ_PREV_PAGE: 220 if (form->page > 0) { 221 old_page = form->page; 222 form->page--; 223 update_page = 1; 224 if (_formi_pos_first_field(form) != E_OK) { 225 form->page = old_page; 226 status = E_REQUEST_DENIED; 227 } 228 } else 229 status = E_REQUEST_DENIED; 230 break; 231 232 case REQ_FIRST_PAGE: 233 old_page = form->page; 234 form->page = 0; 235 update_page = 1; 236 if (_formi_pos_first_field(form) != E_OK) { 237 form->page = old_page; 238 status = E_REQUEST_DENIED; 239 } 240 break; 241 242 case REQ_LAST_PAGE: 243 old_page = form->page; 244 form->page = form->max_page - 1; 245 update_page = 1; 246 if (_formi_pos_first_field(form) != E_OK) { 247 form->page = old_page; 248 status = E_REQUEST_DENIED; 249 } 250 break; 251 252 case REQ_NEXT_FIELD: 253 status = _formi_pos_new_field(form, _FORMI_FORWARD, 254 FALSE); 255 update_field = 1; 256 break; 257 258 case REQ_PREV_FIELD: 259 status = _formi_pos_new_field(form, _FORMI_BACKWARD, 260 FALSE); 261 update_field = 1; 262 break; 263 264 case REQ_FIRST_FIELD: 265 form->cur_field = 0; 266 update_field = 1; 267 break; 268 269 case REQ_LAST_FIELD: 270 form->cur_field = form->field_count - 1; 271 update_field = 1; 272 break; 273 274 case REQ_SNEXT_FIELD: 275 status = _formi_pos_new_field(form, _FORMI_FORWARD, 276 TRUE); 277 update_field = 1; 278 break; 279 280 case REQ_SPREV_FIELD: 281 status = _formi_pos_new_field(form, _FORMI_BACKWARD, 282 TRUE); 283 update_field = 1; 284 break; 285 286 case REQ_SFIRST_FIELD: 287 fieldp = TAILQ_FIRST(&form->sorted_fields); 288 form->cur_field = fieldp->index; 289 update_field = 1; 290 break; 291 292 case REQ_SLAST_FIELD: 293 fieldp = TAILQ_LAST(&form->sorted_fields, 294 _formi_sort_head); 295 form->cur_field = fieldp->index; 296 update_field = 1; 297 break; 298 299 /* 300 * The up, down, left and right field traversals 301 * are rolled up into a single function, allow a 302 * fall through to that function. 303 */ 304 case REQ_LEFT_FIELD: 305 case REQ_RIGHT_FIELD: 306 case REQ_UP_FIELD: 307 case REQ_DOWN_FIELD: 308 status = traverse_form_links(form, c); 309 update_field = 1; 310 break; 311 312 /* the following commands modify the buffer, check if 313 this is allowed first before falling through. */ 314 315 case REQ_DEL_PREV: 316 /* 317 * need to check for the overloading of this 318 * request. If overload flag set and we are 319 * at the start of field this request turns 320 * into a previous field request. Otherwise 321 * fallthrough to the field handler. 322 */ 323 if ((form->opts & O_BS_OVERLOAD) == O_BS_OVERLOAD) { 324 if ((fieldp->start_char == 0) && 325 (fieldp->start_line == 0) && 326 (fieldp->row_xpos == 0)) { 327 update_field = 328 _formi_manipulate_field(form, 329 REQ_PREV_FIELD); 330 break; 331 } 332 } 333 334 /* FALLTHROUGH */ 335 case REQ_NEW_LINE: 336 /* 337 * need to check for the overloading of this 338 * request. If overload flag set and we are 339 * at the start of field this request turns 340 * into a next field request. Otherwise 341 * fallthrough to the field handler. 342 */ 343 if ((form->opts & O_NL_OVERLOAD) == O_NL_OVERLOAD) { 344 if ((fieldp->start_char == 0) && 345 (fieldp->start_line == 0) && 346 (fieldp->row_xpos == 0)) { 347 update_field = 348 _formi_manipulate_field(form, 349 REQ_NEXT_FIELD); 350 break; 351 } 352 } 353 354 /* FALLTHROUGH */ 355 case REQ_INS_CHAR: 356 case REQ_INS_LINE: 357 case REQ_DEL_CHAR: 358 case REQ_DEL_LINE: 359 case REQ_DEL_WORD: 360 case REQ_CLR_EOL: 361 case REQ_CLR_EOF: 362 case REQ_CLR_FIELD: 363 case REQ_OVL_MODE: 364 case REQ_INS_MODE: 365 /* check if we are allowed to edit the field and fall 366 * through if we are. 367 */ 368 if ((form->fields[form->cur_field]->opts & O_EDIT) != O_EDIT) 369 return E_REQUEST_DENIED; 370 371 /* the following manipulate the field contents, bundle 372 them into one function.... */ 373 /* FALLTHROUGH */ 374 case REQ_NEXT_CHAR: 375 case REQ_PREV_CHAR: 376 case REQ_NEXT_LINE: 377 case REQ_PREV_LINE: 378 case REQ_NEXT_WORD: 379 case REQ_PREV_WORD: 380 case REQ_BEG_FIELD: 381 case REQ_END_FIELD: 382 case REQ_BEG_LINE: 383 case REQ_END_LINE: 384 case REQ_LEFT_CHAR: 385 case REQ_RIGHT_CHAR: 386 case REQ_UP_CHAR: 387 case REQ_DOWN_CHAR: 388 case REQ_SCR_FLINE: 389 case REQ_SCR_BLINE: 390 case REQ_SCR_FPAGE: 391 case REQ_SCR_BPAGE: 392 case REQ_SCR_FHPAGE: 393 case REQ_SCR_BHPAGE: 394 case REQ_SCR_FCHAR: 395 case REQ_SCR_BCHAR: 396 case REQ_SCR_HFLINE: 397 case REQ_SCR_HBLINE: 398 case REQ_SCR_HFHALF: 399 case REQ_SCR_HBHALF: 400 update_field = _formi_manipulate_field(form, c); 401 break; 402 403 case REQ_VALIDATION: 404 return _formi_validate_field(form); 405 /* NOTREACHED */ 406 break; 407 408 case REQ_PREV_CHOICE: 409 case REQ_NEXT_CHOICE: 410 update_field = _formi_field_choice(form, c); 411 /* reinit the cursor pos just in case */ 412 if (update_field == 1) { 413 _formi_init_field_xpos(fieldp); 414 fieldp->row_xpos = 0; 415 } 416 break; 417 418 default: /* should not need to do this, but.... */ 419 return E_UNKNOWN_COMMAND; 420 /* NOTREACHED */ 421 break; 422 } 423 } 424 425 /* call the field and form init functions if required. */ 426 if ((c >= REQ_NEXT_PAGE) && (c <= REQ_DOWN_FIELD)) { 427 if (form->field_init != NULL) 428 form->field_init(form); 429 430 /* 431 * if we have a page movement then the form init 432 * needs to be called too 433 */ 434 if ((c <= REQ_LAST_PAGE) && (form->form_init != NULL)) 435 form->form_init(form); 436 437 /* 438 * if there was an error just return now... 439 */ 440 if (status != E_OK) 441 return status; 442 443 /* if we have no error, reset the various offsets */ 444 fieldp = form->fields[form->cur_field]; 445 fieldp->start_char = 0; 446 fieldp->start_line = fieldp->alines; 447 fieldp->cur_line = fieldp->alines; 448 fieldp->row_xpos = 0; 449 fieldp->cursor_ypos = 0; 450 _formi_init_field_xpos(fieldp); 451 } 452 453 if (update_field < 0) 454 return update_field; 455 456 if (update_field == 1) 457 update_page |= _formi_update_field(form, old_field); 458 459 if (update_page == 1) 460 _formi_draw_page(form); 461 462 pos_form_cursor(form); 463 464 if ((update_page == 1) || (update_field == 1)) 465 wrefresh(form->scrwin); 466 467 return E_OK; 468 } 469
Indexes created Sat Sep 20 22:09:52 GMT 2025