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