ncurses 5.3
[ncurses.git] / form / frm_driver.c
1 /****************************************************************************
2  * Copyright (c) 1998,2000 Free Software Foundation, Inc.                   *
3  *                                                                          *
4  * Permission is hereby granted, free of charge, to any person obtaining a  *
5  * copy of this software and associated documentation files (the            *
6  * "Software"), to deal in the Software without restriction, including      *
7  * without limitation the rights to use, copy, modify, merge, publish,      *
8  * distribute, distribute with modifications, sublicense, and/or sell       *
9  * copies of the Software, and to permit persons to whom the Software is    *
10  * furnished to do so, subject to the following conditions:                 *
11  *                                                                          *
12  * The above copyright notice and this permission notice shall be included  *
13  * in all copies or substantial portions of the Software.                   *
14  *                                                                          *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
16  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
18  * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
19  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
20  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
21  * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
22  *                                                                          *
23  * Except as contained in this notice, the name(s) of the above copyright   *
24  * holders shall not be used in advertising or otherwise to promote the     *
25  * sale, use or other dealings in this Software without prior written       *
26  * authorization.                                                           *
27  ****************************************************************************/
28
29 /****************************************************************************
30  *   Author:  Juergen Pfeifer, 1995,1997                                    *
31  *   Contact: http://www.familiepfeifer.de/Contact.aspx?Lang=en             *
32  ****************************************************************************/
33 #include "form.priv.h"
34
35 MODULE_ID("$Id: frm_driver.c,v 1.39 2002/07/06 15:33:27 juergen Exp $")
36
37 /*----------------------------------------------------------------------------
38   This is the core module of the form library. It contains the majority
39   of the driver routines as well as the form_driver function. 
40
41   Essentially this module is nearly the whole library. This is because
42   all the functions in this module depends on some others in the module,
43   so it makes no sense to split them into separate files because they
44   will always be linked together. The only acceptable concern is turnaround
45   time for this module, but now we have all Pentiums or Riscs, so what!
46
47   The driver routines are grouped into nine generic categories:
48
49    a)   Page Navigation            ( all functions prefixed by PN_ )
50         The current page of the form is left and some new page is
51         entered.
52    b)   Inter-Field Navigation     ( all functions prefixed by FN_ )
53         The current field of the form is left and some new field is
54         entered.
55    c)   Intra-Field Navigation     ( all functions prefixed by IFN_ )
56         The current position in the current field is changed. 
57    d)   Vertical Scrolling         ( all functions prefixed by VSC_ )
58         Esseantially this is a specialization of Intra-Field navigation.
59         It has to check for a multi-line field.
60    e)   Horizontal Scrolling       ( all functions prefixed by HSC_ )
61         Esseantially this is a specialization of Intra-Field navigation.
62         It has to check for a single-line field.
63    f)   Field Editing              ( all functions prefixed by FE_ )
64         The content of the current field is changed
65    g)   Edit Mode requests         ( all functions prefixed by EM_ )
66         Switching between insert and overlay mode
67    h)   Field-Validation requests  ( all functions prefixed by FV_ )
68         Perform verifications of the field.
69    i)   Choice requests            ( all functions prefixed by CR_ )
70         Requests to enumerate possible field values
71   --------------------------------------------------------------------------*/
72
73 /*----------------------------------------------------------------------------
74   Some remarks on the placements of assert() macros :
75   I use them only on "strategic" places, i.e. top level entries where
76   I want to make sure that things are set correctly. Throughout subordinate
77   routines I omit them mostly.
78   --------------------------------------------------------------------------*/
79
80 /*
81 Some options that may effect compatibility in behavior to SVr4 forms,
82 but they are here to allow a more intuitive and user friendly behaviour of
83 our form implementation. This doesn't affect the API, so we feel it is
84 uncritical.
85
86 The initial implementation tries to stay very close with the behaviour
87 of the original SVr4 implementation, although in some areas it is quite
88 clear that this isn't the most appropriate way. As far as possible this
89 sources will allow you to build a forms lib that behaves quite similar
90 to SVr4, but now and in the future we will give you better options. 
91 Perhaps at some time we will make this configurable at runtime.
92 */
93
94 /* Implement a more user-friendly previous/next word behaviour */
95 #define FRIENDLY_PREV_NEXT_WORD (1)
96 /* Fix the wrong behaviour for forms with all fields inactive */
97 #define FIX_FORM_INACTIVE_BUG (1)
98 /* Allow dynamic field growth also when navigating past the end */
99 #define GROW_IF_NAVIGATE (1)
100
101 /*----------------------------------------------------------------------------
102   Forward references to some internally used static functions
103   --------------------------------------------------------------------------*/
104 static int Inter_Field_Navigation ( int (* const fct) (FORM *), FORM * form );
105 static int FN_Next_Field (FORM * form);
106 static int FN_Previous_Field (FORM * form);
107 static int FE_New_Line(FORM *);
108 static int FE_Delete_Previous(FORM *);
109 \f
110 /*----------------------------------------------------------------------------
111   Macro Definitions.
112
113   Some Remarks on that: I use the convention to use UPPERCASE for constants
114   defined by Macros. If I provide a macro as a kind of inline routine to
115   provide some logic, I use my Upper_Lower case style.
116   --------------------------------------------------------------------------*/
117
118 /* Calculate the position of a single row in a field buffer */
119 #define Position_Of_Row_In_Buffer(field,row) ((row)*(field)->dcols)
120
121 /* Calculate start address for the fields buffer# N */
122 #define Address_Of_Nth_Buffer(field,N) \
123   ((field)->buf + (N)*(1+Buffer_Length(field)))
124
125 /* Calculate the start address of the row in the fields specified buffer# N */
126 #define Address_Of_Row_In_Nth_Buffer(field,N,row) \
127   (Address_Of_Nth_Buffer(field,N) + Position_Of_Row_In_Buffer(field,row))
128
129 /* Calculate the start address of the row in the fields primary buffer */
130 #define Address_Of_Row_In_Buffer(field,row) \
131   Address_Of_Row_In_Nth_Buffer(field,0,row)
132
133 /* Calculate the start address of the row in the forms current field
134    buffer# N */
135 #define Address_Of_Current_Row_In_Nth_Buffer(form,N) \
136    Address_Of_Row_In_Nth_Buffer((form)->current,N,(form)->currow)
137
138 /* Calculate the start address of the row in the forms current field
139    primary buffer */
140 #define Address_Of_Current_Row_In_Buffer(form) \
141    Address_Of_Current_Row_In_Nth_Buffer(form,0)
142
143 /* Calculate the address of the cursor in the forms current field
144    primary buffer */
145 #define Address_Of_Current_Position_In_Nth_Buffer(form,N) \
146    (Address_Of_Current_Row_In_Nth_Buffer(form,N) + (form)->curcol)
147
148 /* Calculate the address of the cursor in the forms current field
149    buffer# N */
150 #define Address_Of_Current_Position_In_Buffer(form) \
151   Address_Of_Current_Position_In_Nth_Buffer(form,0)
152
153 /* Logic to decide wether or not a field is actually a field with
154    vertical or horizontal scrolling */
155 #define Is_Scroll_Field(field)          \
156    (((field)->drows > (field)->rows) || \
157     ((field)->dcols > (field)->cols))
158
159 /* Logic to decide whether or not a field needs to have an individual window
160    instead of a derived window because it contains invisible parts.
161    This is true for non-public fields and for scrollable fields. */
162 #define Has_Invisible_Parts(field)     \
163   (!((field)->opts & O_PUBLIC)      || \
164    Is_Scroll_Field(field))
165
166 /* Logic to decide whether or not a field needs justification */
167 #define Justification_Allowed(field)        \
168    (((field)->just != NO_JUSTIFICATION)  && \
169     (Single_Line_Field(field))           && \
170     (((field)->dcols == (field)->cols)   && \
171     ((field)->opts & O_STATIC))             )
172
173 /* Logic to determine whether or not a dynamic field may still grow */
174 #define Growable(field) ((field)->status & _MAY_GROW)
175
176 /* Macro to set the attributes for a fields window */
177 #define Set_Field_Window_Attributes(field,win) \
178 (  wbkgdset((win),(chtype)((field)->pad | (field)->back)), \
179    wattrset((win),(field)->fore) )
180
181 /* Logic to decide whether or not a field really appears on the form */
182 #define Field_Really_Appears(field)         \
183   ((field->form)                          &&\
184    (field->form->status & _POSTED)        &&\
185    (field->opts & O_VISIBLE)              &&\
186    (field->page == field->form->curpage))
187
188 /* Logic to determine whether or not we are on the first position in the
189    current field */
190 #define First_Position_In_Current_Field(form) \
191   (((form)->currow==0) && ((form)->curcol==0))
192
193
194 #define Minimum(a,b) (((a)<=(b)) ? (a) : (b))
195 #define Maximum(a,b) (((a)>=(b)) ? (a) : (b))
196 \f
197 /*---------------------------------------------------------------------------
198 |   Facility      :  libnform  
199 |   Function      :  static char *Get_Start_Of_Data(char * buf, int blen)
200 |   
201 |   Description   :  Return pointer to first non-blank position in buffer.
202 |                    If buffer is empty return pointer to buffer itself.
203 |
204 |   Return Values :  Pointer to first non-blank position in buffer
205 +--------------------------------------------------------------------------*/
206 INLINE static char *Get_Start_Of_Data(char * buf, int blen)
207 {
208   char *p   = buf;
209   char *end = &buf[blen];
210
211   assert(buf && blen>=0);
212   while( (p < end) && is_blank(*p) ) 
213     p++;
214   return( (p==end) ? buf : p );
215 }
216
217 /*---------------------------------------------------------------------------
218 |   Facility      :  libnform  
219 |   Function      :  static char *After_End_Of_Data(char * buf, int blen)
220 |   
221 |   Description   :  Return pointer after last non-blank position in buffer.
222 |                    If buffer is empty, return pointer to buffer itself.
223 |
224 |   Return Values :  Pointer to position after last non-blank position in 
225 |                    buffer.
226 +--------------------------------------------------------------------------*/
227 INLINE static char *After_End_Of_Data(char * buf,int blen)
228 {
229   char *p   = &buf[blen];
230   
231   assert(buf && blen>=0);
232   while( (p>buf) && is_blank(p[-1]) ) 
233     p--;
234   return( p );
235 }
236
237 /*---------------------------------------------------------------------------
238 |   Facility      :  libnform  
239 |   Function      :  static char *Get_First_Whitespace_Character(
240 |                                     char * buf, int   blen)
241 |   
242 |   Description   :  Position to the first whitespace character.
243 |
244 |   Return Values :  Pointer to first whitespace character in buffer.
245 +--------------------------------------------------------------------------*/
246 INLINE static char *Get_First_Whitespace_Character(char * buf, int blen)
247 {
248   char *p   = buf;
249   char *end = &p[blen];
250   
251   assert(buf && blen>=0);
252   while( (p < end) && !is_blank(*p)) 
253     p++;
254   return( (p==end) ? buf : p );
255 }
256
257 /*---------------------------------------------------------------------------
258 |   Facility      :  libnform  
259 |   Function      :  static char *After_Last_Whitespace_Character(
260 |                                     char * buf, int blen)
261 |   
262 |   Description   :  Get the position after the last whitespace character.
263 |
264 |   Return Values :  Pointer to position after last whitespace character in 
265 |                    buffer.
266 +--------------------------------------------------------------------------*/
267 INLINE static char *After_Last_Whitespace_Character(char * buf, int blen)
268 {
269   char *p   = &buf[blen];
270   
271   assert(buf && blen>=0);
272   while( (p>buf) && !is_blank(p[-1]) ) 
273     p--;
274   return( p );
275 }
276
277 /* Set this to 1 to use the div_t version. This is a good idea if your
278    compiler has an intrinsic div() support. Unfortunately GNU-C has it
279    not yet. 
280    N.B.: This only works if form->curcol follows immediately form->currow
281          and both are of type int. 
282 */
283 #define USE_DIV_T (0)
284
285 /*---------------------------------------------------------------------------
286 |   Facility      :  libnform  
287 |   Function      :  static void Adjust_Cursor_Position(
288 |                                       FORM * form, const char * pos)
289 |   
290 |   Description   :  Set current row and column of the form to values 
291 |                    corresponding to the buffer position.
292 |
293 |   Return Values :  -
294 +--------------------------------------------------------------------------*/
295 INLINE static void Adjust_Cursor_Position(FORM * form, const char * pos)
296 {
297   FIELD *field;
298   int idx;
299
300   field = form->current;
301   assert( pos >= field->buf && field->dcols > 0);
302   idx = (int)( pos - field->buf );
303 #if USE_DIV_T
304   *((div_t *)&(form->currow)) = div(idx,field->dcols);
305 #else
306   form->currow = idx / field->dcols;
307   form->curcol = idx - field->cols * form->currow;
308 #endif  
309   if ( field->drows < form->currow )
310     form->currow = 0;
311 }
312
313 /*---------------------------------------------------------------------------
314 |   Facility      :  libnform  
315 |   Function      :  static void Buffer_To_Window(
316 |                                      const FIELD  * field,
317 |                                      WINDOW * win)
318 |   
319 |   Description   :  Copy the buffer to the window. If its a multiline
320 |                    field, the buffer is split to the lines of the
321 |                    window without any editing.
322 |
323 |   Return Values :  -
324 +--------------------------------------------------------------------------*/
325 static void Buffer_To_Window(const FIELD  * field, WINDOW * win)
326 {
327   int width, height;
328   int len;
329   int row;
330   char *pBuffer;
331
332   assert(win && field);
333
334   width  = getmaxx(win);
335   height = getmaxy(win);
336
337   for(row=0, pBuffer=field->buf; 
338       row < height; 
339       row++, pBuffer += width )
340     {
341       if ((len = (int)( After_End_Of_Data( pBuffer, width ) - pBuffer )) > 0)
342         {
343           wmove( win, row, 0 );
344           waddnstr( win, pBuffer, len );
345         }
346     }   
347 }
348
349 /*---------------------------------------------------------------------------
350 |   Facility      :  libnform  
351 |   Function      :  static void Window_To_Buffer(
352 |                                          WINDOW * win,
353 |                                          FIELD  * field)
354 |   
355 |   Description   :  Copy the content of the window into the buffer.
356 |                    The multiple lines of a window are simply
357 |                    concatenated into the buffer. Pad characters in
358 |                    the window will be replaced by blanks in the buffer.
359 |
360 |   Return Values :  -
361 +--------------------------------------------------------------------------*/
362 static void Window_To_Buffer(WINDOW * win, FIELD  * field)
363 {
364   int pad;
365   int len = 0;
366   char *p;
367   int row, height;
368   
369   assert(win && field && field->buf );
370
371   pad = field->pad;
372   p = field->buf;
373   height = getmaxy(win);
374
375   for(row=0; (row < height) && (row < field->drows); row++ )
376     {
377       wmove( win, row, 0 );
378       len += winnstr( win, p+len, field->dcols );
379     }
380   p[len] = '\0';
381
382   /* replace visual padding character by blanks in buffer */
383   if (pad != C_BLANK)
384     {
385       int i;
386       for(i=0; i<len; i++, p++)
387         {
388           if (*p==pad) 
389             *p = C_BLANK;
390         }
391     }
392 }
393
394 /*---------------------------------------------------------------------------
395 |   Facility      :  libnform  
396 |   Function      :  static void Synchronize_Buffer(FORM * form)
397 |   
398 |   Description   :  If there was a change, copy the content of the
399 |                    window into the buffer, so the buffer is synchronized
400 |                    with the windows content. We have to indicate that the
401 |                    buffer needs validation due to the change.
402 |
403 |   Return Values :  -
404 +--------------------------------------------------------------------------*/
405 INLINE static void Synchronize_Buffer(FORM * form)
406 {
407   if (form->status & _WINDOW_MODIFIED)
408     {
409       form->status &= ~_WINDOW_MODIFIED;
410       form->status |=  _FCHECK_REQUIRED;
411       Window_To_Buffer(form->w,form->current);
412       wmove(form->w,form->currow,form->curcol);
413     }
414 }
415
416 /*---------------------------------------------------------------------------
417 |   Facility      :  libnform  
418 |   Function      :  static bool Field_Grown( FIELD *field, int amount)
419 |   
420 |   Description   :  This function is called for growable dynamic fields
421 |                    only. It has to increase the buffers and to allocate
422 |                    a new window for this field.
423 |                    This function has the side effect to set a new
424 |                    field-buffer pointer, the dcols and drows values
425 |                    as well as a new current Window for the field.
426 |
427 |   Return Values :  TRUE     - field successfully increased
428 |                    FALSE    - there was some error
429 +--------------------------------------------------------------------------*/
430 static bool Field_Grown(FIELD * field, int amount)
431 {
432   bool result = FALSE;
433
434   if (field && Growable(field))
435     {
436       bool single_line_field = Single_Line_Field(field);
437       int old_buflen = Buffer_Length(field);
438       int new_buflen;
439       int old_dcols = field->dcols;
440       int old_drows = field->drows;
441       char *oldbuf  = field->buf;
442       char *newbuf;
443
444       int growth;
445       FORM *form = field->form;
446       bool need_visual_update = ((form != (FORM *)0)      &&
447                                  (form->status & _POSTED) &&
448                                  (form->current==field));
449       
450       if (need_visual_update)
451         Synchronize_Buffer(form);
452       
453       if (single_line_field)
454         {
455           growth = field->cols * amount;
456           if (field->maxgrow)
457             growth = Minimum(field->maxgrow - field->dcols,growth);
458           field->dcols += growth;
459           if (field->dcols == field->maxgrow)
460             field->status &= ~_MAY_GROW;
461         }
462       else
463         {
464           growth = (field->rows + field->nrow) * amount;
465           if (field->maxgrow)
466             growth = Minimum(field->maxgrow - field->drows,growth);
467           field->drows += growth;
468           if (field->drows == field->maxgrow)
469             field->status &= ~_MAY_GROW;
470         }
471       /* drows, dcols changed, so we get really the new buffer length */
472       new_buflen = Buffer_Length(field);
473       newbuf=(char *)malloc((size_t)Total_Buffer_Size(field));
474       if (!newbuf)
475         { /* restore to previous state */
476           field->dcols = old_dcols;
477           field->drows = old_drows;
478           if (( single_line_field && (field->dcols!=field->maxgrow)) ||
479               (!single_line_field && (field->drows!=field->maxgrow)))
480             field->status |= _MAY_GROW;
481           return FALSE;
482         }
483       else
484         { /* Copy all the buffers. This is the reason why we can't
485              just use realloc().
486              */
487           int i;
488           char *old_bp;
489           char *new_bp;
490           
491           field->buf = newbuf;
492           for(i=0;i<=field->nbuf;i++)
493             {
494               new_bp = Address_Of_Nth_Buffer(field,i);
495               old_bp = oldbuf + i*(1+old_buflen);
496               memcpy(new_bp,old_bp,(size_t)old_buflen);
497               if (new_buflen > old_buflen)
498                 memset(new_bp + old_buflen,C_BLANK,
499                        (size_t)(new_buflen - old_buflen));
500               *(new_bp + new_buflen) = '\0';
501             }
502
503           if (need_visual_update)
504             {         
505               WINDOW *new_window = newpad(field->drows,field->dcols);
506               if (!new_window)
507                 { /* restore old state */
508                   field->dcols = old_dcols;
509                   field->drows = old_drows;
510                   field->buf   = oldbuf;
511                   if (( single_line_field              && 
512                         (field->dcols!=field->maxgrow)) ||
513                       (!single_line_field              && 
514                        (field->drows!=field->maxgrow)))
515                     field->status |= _MAY_GROW;
516                   free( newbuf );
517                   return FALSE;
518                 }
519               assert(form!=(FORM *)0);
520               if (form->w)
521                 delwin(form->w);
522               form->w = new_window;
523               Set_Field_Window_Attributes(field,form->w);
524               werase(form->w);
525               Buffer_To_Window(field,form->w);
526               untouchwin(form->w);
527               wmove(form->w,form->currow,form->curcol);
528             }
529
530           free(oldbuf);
531           /* reflect changes in linked fields */
532           if (field != field->link)
533             {
534               FIELD *linked_field;
535               for(linked_field = field->link;
536                   linked_field!= field;
537                   linked_field = linked_field->link)
538                 {
539                   linked_field->buf   = field->buf;
540                   linked_field->drows = field->drows;
541                   linked_field->dcols = field->dcols;
542                 }
543             }
544           result = TRUE;
545         }       
546     }
547   return(result);
548 }
549
550 /*---------------------------------------------------------------------------
551 |   Facility      :  libnform  
552 |   Function      :  int _nc_Position_Form_Cursor(FORM * form)
553 |   
554 |   Description   :  Position the cursor in the window for the current
555 |                    field to be in sync. with the currow and curcol 
556 |                    values.
557 |
558 |   Return Values :  E_OK              - success
559 |                    E_BAD_ARGUMENT    - invalid form pointer
560 |                    E_SYSTEM_ERROR    - form has no current field or
561 |                                        field-window
562 +--------------------------------------------------------------------------*/
563 NCURSES_EXPORT(int)
564 _nc_Position_Form_Cursor (FORM * form)
565 {
566   FIELD  *field;
567   WINDOW *formwin;
568   
569   if (!form)
570     return(E_BAD_ARGUMENT);
571
572   if (!form->w || !form->current) 
573     return(E_SYSTEM_ERROR);
574
575   field    = form->current;
576   formwin  = Get_Form_Window(form);
577
578   wmove( form->w, form->currow, form->curcol );
579   if ( Has_Invisible_Parts(field) )
580     {
581       /* in this case fieldwin isn't derived from formwin, so we have
582          to move the cursor in formwin by hand... */
583       wmove(formwin,
584             field->frow + form->currow - form->toprow,
585             field->fcol + form->curcol - form->begincol);
586       wcursyncup(formwin);
587     }
588   else 
589     wcursyncup(form->w);
590   return(E_OK);
591 }
592
593 /*---------------------------------------------------------------------------
594 |   Facility      :  libnform  
595 |   Function      :  int _nc_Refresh_Current_Field(FORM * form)
596 |   
597 |   Description   :  Propagate the changes in the fields window to the
598 |                    window of the form.
599 |
600 |   Return Values :  E_OK              - on success
601 |                    E_BAD_ARGUMENT    - invalid form pointer
602 |                    E_SYSTEM_ERROR    - general error
603 +--------------------------------------------------------------------------*/
604 NCURSES_EXPORT(int)
605 _nc_Refresh_Current_Field (FORM * form)
606 {
607   WINDOW *formwin;
608   FIELD  *field;
609
610   if (!form)
611     RETURN(E_BAD_ARGUMENT);
612
613   if (!form->w || !form->current) 
614     RETURN(E_SYSTEM_ERROR);
615
616   field    = form->current;
617   formwin  = Get_Form_Window(form);
618
619   if (field->opts & O_PUBLIC)
620     {
621       if (Is_Scroll_Field(field))
622         {
623           /* Again, in this case the fieldwin isn't derived from formwin,
624              so we have to perform a copy operation. */
625           if (Single_Line_Field(field))
626             { /* horizontal scrolling */
627               if (form->curcol < form->begincol)
628                   form->begincol = form->curcol;
629               else
630                 {
631                   if (form->curcol >= (form->begincol + field->cols))
632                       form->begincol = form->curcol - field->cols + 1;
633                 }
634               copywin(form->w,
635                       formwin,
636                       0,
637                       form->begincol,
638                       field->frow,
639                       field->fcol,
640                       field->frow,
641                       field->cols + field->fcol - 1,
642                       0);
643             }
644           else
645             { /* A multiline, i.e. vertical scrolling field */
646               int row_after_bottom,first_modified_row,first_unmodified_row;
647
648               if (field->drows > field->rows)
649                 {
650                   row_after_bottom = form->toprow + field->rows;
651                   if (form->currow < form->toprow)
652                     {
653                       form->toprow = form->currow;
654                       field->status |= _NEWTOP;
655                     }
656                   if (form->currow >= row_after_bottom)
657                     {
658                       form->toprow = form->currow - field->rows + 1;
659                       field->status |= _NEWTOP;
660                     }
661                   if (field->status & _NEWTOP)
662                     { /* means we have to copy whole range */
663                       first_modified_row = form->toprow;
664                       first_unmodified_row = first_modified_row + field->rows;
665                       field->status &= ~_NEWTOP;
666                     }
667                   else 
668                     { /* we try to optimize : finding the range of touched
669                          lines */
670                       first_modified_row = form->toprow;
671                       while(first_modified_row < row_after_bottom)
672                         {
673                           if (is_linetouched(form->w,first_modified_row)) 
674                             break;
675                           first_modified_row++;
676                         }
677                       first_unmodified_row = first_modified_row;
678                       while(first_unmodified_row < row_after_bottom)
679                         {
680                           if (!is_linetouched(form->w,first_unmodified_row)) 
681                             break;
682                           first_unmodified_row++;
683                         }
684                     }
685                 }
686               else
687                 {
688                   first_modified_row   = form->toprow;
689                   first_unmodified_row = first_modified_row + field->rows;
690                 }
691               if (first_unmodified_row != first_modified_row)
692                 copywin(form->w,
693                         formwin,
694                         first_modified_row,
695                         0,
696                         field->frow + first_modified_row - form->toprow,
697                         field->fcol,
698                         field->frow + first_unmodified_row - form->toprow - 1,
699                         field->cols + field->fcol - 1,
700                         0);
701             }
702           wsyncup(formwin);
703         }
704       else
705         { /* if the field-window is simply a derived window, i.e. contains
706              no invisible parts, the whole thing is trivial 
707           */
708           wsyncup(form->w);
709         }
710     }
711   untouchwin(form->w);
712   return _nc_Position_Form_Cursor(form);
713 }
714         
715 /*---------------------------------------------------------------------------
716 |   Facility      :  libnform  
717 |   Function      :  static void Perform_Justification(
718 |                                        FIELD  * field,
719 |                                        WINDOW * win)
720 |   
721 |   Description   :  Output field with requested justification 
722 |
723 |   Return Values :  -
724 +--------------------------------------------------------------------------*/
725 static void Perform_Justification(FIELD  * field, WINDOW * win)
726 {
727   char *bp;
728   int len;
729   int col  = 0;
730
731   bp  = Get_Start_Of_Data(field->buf,Buffer_Length(field));
732   len = (int)(After_End_Of_Data(field->buf,Buffer_Length(field)) - bp);
733
734   if (len>0)
735     {
736       assert(win && (field->drows == 1) && (field->dcols == field->cols));
737
738       switch(field->just)
739         {
740         case JUSTIFY_LEFT:
741           break;
742         case JUSTIFY_CENTER:
743           col = (field->cols - len)/2;
744           break;
745         case JUSTIFY_RIGHT:
746           col = field->cols - len;
747           break;
748         default:
749           break;
750         }
751
752       wmove(win,0,col);
753       waddnstr(win,bp,len);
754     }
755 }
756
757 /*---------------------------------------------------------------------------
758 |   Facility      :  libnform  
759 |   Function      :  static void Undo_Justification(
760 |                                     FIELD  * field,
761 |                                     WINDOW * win)
762 |   
763 |   Description   :  Display field without any justification, i.e.
764 |                    left justified
765 |
766 |   Return Values :  -
767 +--------------------------------------------------------------------------*/
768 static void Undo_Justification(FIELD  * field, WINDOW * win)
769 {
770   char *bp;
771   int len;
772
773   bp  = Get_Start_Of_Data(field->buf,Buffer_Length(field));
774   len = (int)(After_End_Of_Data(field->buf,Buffer_Length(field))-bp);
775
776   if (len>0)
777     {
778       assert(win);
779       wmove(win,0,0);
780       waddnstr(win,bp,len);
781     }
782 }
783
784 /*---------------------------------------------------------------------------
785 |   Facility      :  libnform  
786 |   Function      :  static bool Check_Char(
787 |                                           FIELDTYPE * typ,
788 |                                           int ch,
789 |                                           TypeArgument *argp)
790 |   
791 |   Description   :  Perform a single character check for character ch
792 |                    according to the fieldtype instance.  
793 |
794 |   Return Values :  TRUE             - Character is valid
795 |                    FALSE            - Character is invalid
796 +--------------------------------------------------------------------------*/
797 static bool Check_Char(FIELDTYPE * typ, int ch, TypeArgument *argp)
798 {
799   if (typ) 
800     {
801       if (typ->status & _LINKED_TYPE)
802         {
803           assert(argp);
804           return(
805             Check_Char(typ->left ,ch,argp->left ) ||
806             Check_Char(typ->right,ch,argp->right) );
807         } 
808       else 
809         {
810           if (typ->ccheck)
811             return typ->ccheck(ch,(void *)argp);
812         }
813     }
814   return (isprint((unsigned char)ch) ? TRUE : FALSE);
815 }
816
817 /*---------------------------------------------------------------------------
818 |   Facility      :  libnform  
819 |   Function      :  static int Display_Or_Erase_Field(
820 |                                           FIELD * field,
821 |                                           bool bEraseFlag)
822 |   
823 |   Description   :  Create a subwindow for the field and display the
824 |                    buffer contents (apply justification if required)
825 |                    or simply erase the field.
826 |
827 |   Return Values :  E_OK           - on success
828 |                    E_SYSTEM_ERROR - some error (typical no memory)
829 +--------------------------------------------------------------------------*/
830 static int Display_Or_Erase_Field(FIELD * field, bool bEraseFlag)
831 {
832   WINDOW *win;
833   WINDOW *fwin;
834
835   if (!field)
836     return E_SYSTEM_ERROR;
837
838   fwin = Get_Form_Window(field->form);
839   win  = derwin(fwin,
840                 field->rows,field->cols,field->frow,field->fcol);
841
842   if (!win) 
843     return E_SYSTEM_ERROR;
844   else
845     {
846       if (field->opts & O_VISIBLE)
847         Set_Field_Window_Attributes(field,win);
848       else
849         wattrset(win,getattrs(fwin));
850       werase(win);
851     }
852
853   if (!bEraseFlag)
854     {
855       if (field->opts & O_PUBLIC)
856         {
857           if (Justification_Allowed(field))
858             Perform_Justification(field,win);
859           else
860             Buffer_To_Window(field,win);
861         }
862       field->status &= ~_NEWTOP;
863     }
864   wsyncup(win);
865   delwin(win);
866   return E_OK;
867 }
868
869 /* Macros to preset the bEraseFlag */
870 #define Display_Field(field) Display_Or_Erase_Field(field,FALSE)
871 #define Erase_Field(field)   Display_Or_Erase_Field(field,TRUE)
872
873 /*---------------------------------------------------------------------------
874 |   Facility      :  libnform  
875 |   Function      :  static int Synchronize_Field(FIELD * field)
876 |   
877 |   Description   :  Synchronize the windows content with the value in
878 |                    the buffer.
879 |
880 |   Return Values :  E_OK                - success
881 |                    E_BAD_ARGUMENT      - invalid field pointer 
882 |                    E_SYSTEM_ERROR      - some severe basic error
883 +--------------------------------------------------------------------------*/
884 static int Synchronize_Field(FIELD * field)
885 {
886   FORM *form;
887   int res = E_OK;
888
889   if (!field)
890     return(E_BAD_ARGUMENT);
891
892   if (((form=field->form) != (FORM *)0)
893       && Field_Really_Appears(field))
894     {
895       if (field == form->current)
896         { 
897           form->currow  = form->curcol = form->toprow = form->begincol = 0;
898           werase(form->w);
899       
900           if ( (field->opts & O_PUBLIC) && Justification_Allowed(field) )
901             Undo_Justification( field, form->w );
902           else
903             Buffer_To_Window( field, form->w );
904           
905           field->status |= _NEWTOP;
906           res = _nc_Refresh_Current_Field( form );
907         }
908       else
909         res = Display_Field( field );
910     }
911   field->status |= _CHANGED;
912   return(res);
913 }
914
915 /*---------------------------------------------------------------------------
916 |   Facility      :  libnform  
917 |   Function      :  static int Synchronize_Linked_Fields(FIELD * field)
918 |   
919 |   Description   :  Propagate the Synchronize_Field function to all linked
920 |                    fields. The first error that occurs in the sequence
921 |                    of updates is the returnvalue.
922 |
923 |   Return Values :  E_OK                - success
924 |                    E_BAD_ARGUMENT      - invalid field pointer 
925 |                    E_SYSTEM_ERROR      - some severe basic error
926 +--------------------------------------------------------------------------*/
927 static int Synchronize_Linked_Fields(FIELD * field)
928 {
929   FIELD *linked_field;
930   int res = E_OK;
931   int syncres;
932
933   if (!field)
934     return(E_BAD_ARGUMENT);
935
936   if (!field->link)
937     return(E_SYSTEM_ERROR);
938
939   for(linked_field = field->link; 
940       linked_field!= field;
941       linked_field = linked_field->link )
942     {
943       if (((syncres=Synchronize_Field(linked_field)) != E_OK) &&
944           (res==E_OK))
945         res = syncres;
946     }
947   return(res);
948 }
949
950 /*---------------------------------------------------------------------------
951 |   Facility      :  libnform  
952 |   Function      :  int _nc_Synchronize_Attributes(FIELD * field)
953 |   
954 |   Description   :  If a fields visual attributes have changed, this
955 |                    routine is called to propagate those changes to the
956 |                    screen.  
957 |
958 |   Return Values :  E_OK             - success
959 |                    E_BAD_ARGUMENT   - invalid field pointer
960 |                    E_SYSTEM_ERROR   - some severe basic error
961 +--------------------------------------------------------------------------*/
962 NCURSES_EXPORT(int)
963 _nc_Synchronize_Attributes (FIELD * field)
964 {
965   FORM *form;
966   int res = E_OK;
967   WINDOW *formwin;
968
969   if (!field)
970     return(E_BAD_ARGUMENT);
971
972   if (((form=field->form) != (FORM *)0)
973       && Field_Really_Appears(field))
974     {    
975       if (form->current==field)
976         {
977           Synchronize_Buffer(form);
978           Set_Field_Window_Attributes(field,form->w);
979           werase(form->w);
980           if (field->opts & O_PUBLIC)
981             {
982               if (Justification_Allowed(field))
983                 Undo_Justification(field,form->w);
984               else 
985                 Buffer_To_Window(field,form->w);
986             }
987           else 
988             {
989               formwin = Get_Form_Window(form); 
990               copywin(form->w,formwin,
991                       0,0,
992                       field->frow,field->fcol,
993                       field->rows-1,field->cols-1,0);
994               wsyncup(formwin);
995               Buffer_To_Window(field,form->w);
996               field->status |= _NEWTOP; /* fake refresh to paint all */
997               _nc_Refresh_Current_Field(form);
998             }
999         }
1000       else 
1001         {
1002           res = Display_Field(field);
1003         }
1004     }
1005   return(res);
1006 }
1007
1008 /*---------------------------------------------------------------------------
1009 |   Facility      :  libnform  
1010 |   Function      :  int _nc_Synchronize_Options(FIELD * field,
1011 |                                                Field_Options newopts)
1012 |   
1013 |   Description   :  If a fields options have changed, this routine is
1014 |                    called to propagate these changes to the screen and
1015 |                    to really change the behaviour of the field.
1016 |
1017 |   Return Values :  E_OK                - success
1018 |                    E_BAD_ARGUMENT      - invalid field pointer 
1019 |                    E_SYSTEM_ERROR      - some severe basic error
1020 +--------------------------------------------------------------------------*/
1021 NCURSES_EXPORT(int)
1022 _nc_Synchronize_Options
1023 (FIELD *field, Field_Options newopts)
1024 {
1025   Field_Options oldopts;
1026   Field_Options changed_opts;
1027   FORM *form;
1028   int res = E_OK;
1029
1030   if (!field)
1031     return(E_BAD_ARGUMENT);
1032
1033   oldopts      = field->opts;
1034   changed_opts = oldopts ^ newopts;
1035   field->opts  = newopts;
1036   form         = field->form;
1037
1038   if (form)
1039     {
1040       if (form->current == field)
1041         {
1042           field->opts = oldopts;
1043           return(E_CURRENT);
1044         }
1045
1046       if (form->status & _POSTED)
1047         {
1048           if ((form->curpage == field->page))
1049             {
1050               if (changed_opts & O_VISIBLE)
1051                 {
1052                   if (newopts & O_VISIBLE)
1053                     res = Display_Field(field);
1054                   else
1055                     res = Erase_Field(field);
1056                 }
1057               else
1058                 {
1059                   if ((changed_opts & O_PUBLIC) &&
1060                       (newopts & O_VISIBLE))
1061                     res = Display_Field(field);
1062                 }
1063             }
1064         }
1065     }
1066
1067   if (changed_opts & O_STATIC)
1068     {
1069       bool single_line_field = Single_Line_Field(field);
1070       int res2 = E_OK;
1071
1072       if (newopts & O_STATIC)
1073         { /* the field becomes now static */
1074           field->status &= ~_MAY_GROW;
1075           /* if actually we have no hidden columns, justification may
1076              occur again */
1077           if (single_line_field                 &&
1078               (field->cols == field->dcols)     &&
1079               (field->just != NO_JUSTIFICATION) &&
1080               Field_Really_Appears(field))
1081             {
1082               res2 = Display_Field(field);
1083             }
1084         }
1085       else
1086         { /* field is no longer static */
1087           if ((field->maxgrow==0) ||
1088               ( single_line_field && (field->dcols < field->maxgrow)) ||
1089               (!single_line_field && (field->drows < field->maxgrow)))
1090             {
1091               field->status |= _MAY_GROW;
1092               /* a field with justification now changes its behaviour,
1093                  so we must redisplay it */
1094               if (single_line_field                 &&
1095                   (field->just != NO_JUSTIFICATION) &&
1096                   Field_Really_Appears(field))
1097                 {
1098                   res2 = Display_Field(field);
1099                 }        
1100             }     
1101         }
1102       if (res2 != E_OK)
1103         res = res2;
1104     }
1105
1106   return(res);
1107 }
1108
1109 /*---------------------------------------------------------------------------
1110 |   Facility      :  libnform  
1111 |   Function      :  int _nc_Set_Current_Field(FORM  * form,
1112 |                                              FIELD * newfield)
1113 |   
1114 |   Description   :  Make the newfield the new current field.
1115 |
1116 |   Return Values :  E_OK                - success
1117 |                    E_BAD_ARGUMENT      - invalid form or field pointer 
1118 |                    E_SYSTEM_ERROR      - some severe basic error
1119 +--------------------------------------------------------------------------*/
1120 NCURSES_EXPORT(int)
1121 _nc_Set_Current_Field
1122 (FORM  *form, FIELD *newfield)
1123 {
1124   FIELD  *field;
1125   WINDOW *new_window;
1126
1127   if (!form || !newfield || !form->current || (newfield->form!=form))
1128     return(E_BAD_ARGUMENT);
1129
1130   if ( (form->status & _IN_DRIVER) )
1131     return(E_BAD_STATE);
1132
1133   if (!(form->field))
1134     return(E_NOT_CONNECTED);
1135
1136   field = form->current;
1137  
1138   if ((field!=newfield) || 
1139       !(form->status & _POSTED))
1140     {
1141       if ((form->w) && 
1142           (field->opts & O_VISIBLE) &&
1143           (field->form->curpage == field->page))
1144         {
1145           _nc_Refresh_Current_Field(form);
1146           if (field->opts & O_PUBLIC)
1147             {
1148               if (field->drows > field->rows)
1149                 {
1150                   if (form->toprow==0)
1151                     field->status &= ~_NEWTOP;
1152                   else 
1153                     field->status |= _NEWTOP;
1154                 } 
1155               else 
1156                 {
1157                   if (Justification_Allowed(field))
1158                     {
1159                       Window_To_Buffer(form->w,field);
1160                       werase(form->w);
1161                       Perform_Justification(field,form->w);
1162                       wsyncup(form->w);
1163                     }
1164                 }
1165             }
1166           delwin(form->w);
1167           form->w = (WINDOW *)0;
1168         }
1169       
1170       field = newfield;
1171
1172       if (Has_Invisible_Parts(field))
1173         new_window = newpad(field->drows,field->dcols);
1174       else 
1175         new_window = derwin(Get_Form_Window(form),
1176                             field->rows,field->cols,field->frow,field->fcol);
1177
1178       if (!new_window) 
1179         return(E_SYSTEM_ERROR);
1180
1181       form->current = field;
1182
1183       if (form->w)
1184         delwin(form->w);
1185       form->w       = new_window;
1186
1187       form->status &= ~_WINDOW_MODIFIED;
1188       Set_Field_Window_Attributes(field,form->w);
1189
1190       if (Has_Invisible_Parts(field))
1191         {
1192           werase(form->w);
1193           Buffer_To_Window(field,form->w);
1194         } 
1195       else 
1196         {
1197           if (Justification_Allowed(field))
1198             {
1199               werase(form->w);
1200               Undo_Justification(field,form->w);
1201               wsyncup(form->w);
1202             }
1203         }
1204
1205       untouchwin(form->w);
1206     }
1207
1208   form->currow = form->curcol = form->toprow = form->begincol = 0;
1209   return(E_OK);
1210 }
1211 \f
1212 /*----------------------------------------------------------------------------
1213   Intra-Field Navigation routines
1214   --------------------------------------------------------------------------*/
1215
1216 /*---------------------------------------------------------------------------
1217 |   Facility      :  libnform  
1218 |   Function      :  static int IFN_Next_Character(FORM * form)
1219 |   
1220 |   Description   :  Move to the next character in the field. In a multiline
1221 |                    field this wraps at the end of the line.
1222 |
1223 |   Return Values :  E_OK                - success
1224 |                    E_REQUEST_DENIED    - at the rightmost position
1225 +--------------------------------------------------------------------------*/
1226 static int IFN_Next_Character(FORM * form)
1227 {
1228   FIELD *field = form->current;
1229   
1230   if ((++(form->curcol))==field->dcols)
1231     {
1232       if ((++(form->currow))==field->drows)
1233         {
1234 #if GROW_IF_NAVIGATE
1235           if (!Single_Line_Field(field) && Field_Grown(field,1)) {
1236             form->curcol = 0;
1237             return(E_OK);
1238           }
1239 #endif
1240           form->currow--;
1241 #if GROW_IF_NAVIGATE
1242           if (Single_Line_Field(field) && Field_Grown(field,1))
1243             return(E_OK);
1244 #endif
1245           form->curcol--;
1246           return(E_REQUEST_DENIED);
1247         }
1248       form->curcol = 0;
1249     }
1250   return(E_OK);
1251 }
1252
1253 /*---------------------------------------------------------------------------
1254 |   Facility      :  libnform  
1255 |   Function      :  static int IFN_Previous_Character(FORM * form)
1256 |   
1257 |   Description   :  Move to the previous character in the field. In a 
1258 |                    multiline field this wraps and the beginning of the 
1259 |                    line.
1260 |
1261 |   Return Values :  E_OK                - success
1262 |                    E_REQUEST_DENIED    - at the leftmost position
1263 +--------------------------------------------------------------------------*/
1264 static int IFN_Previous_Character(FORM * form)
1265 {
1266   if ((--(form->curcol))<0)
1267     {
1268       if ((--(form->currow))<0)
1269         {
1270           form->currow++;
1271           form->curcol++;
1272           return(E_REQUEST_DENIED);
1273         }
1274       form->curcol = form->current->dcols - 1;
1275     }
1276   return(E_OK);
1277 }
1278
1279 /*---------------------------------------------------------------------------
1280 |   Facility      :  libnform  
1281 |   Function      :  static int IFN_Next_Line(FORM * form)
1282 |   
1283 |   Description   :  Move to the beginning of the next line in the field
1284 |
1285 |   Return Values :  E_OK                - success
1286 |                    E_REQUEST_DENIED    - at the last line
1287 +--------------------------------------------------------------------------*/
1288 static int IFN_Next_Line(FORM * form)
1289 {
1290   FIELD *field = form->current;
1291
1292   if ((++(form->currow))==field->drows)
1293     {
1294 #if GROW_IF_NAVIGATE
1295       if (!Single_Line_Field(field) && Field_Grown(field,1))
1296         return(E_OK);
1297 #endif
1298       form->currow--;
1299       return(E_REQUEST_DENIED);
1300     }
1301   form->curcol = 0;
1302   return(E_OK);
1303 }
1304
1305 /*---------------------------------------------------------------------------
1306 |   Facility      :  libnform  
1307 |   Function      :  static int IFN_Previous_Line(FORM * form)
1308 |   
1309 |   Description   :  Move to the beginning of the previous line in the field
1310 |
1311 |   Return Values :  E_OK                - success
1312 |                    E_REQUEST_DENIED    - at the first line
1313 +--------------------------------------------------------------------------*/
1314 static int IFN_Previous_Line(FORM * form)
1315 {
1316   if ( (--(form->currow)) < 0 )
1317     {
1318       form->currow++;
1319       return(E_REQUEST_DENIED);
1320     }
1321   form->curcol = 0;
1322   return(E_OK);
1323 }
1324
1325 /*---------------------------------------------------------------------------
1326 |   Facility      :  libnform  
1327 |   Function      :  static int IFN_Next_Word(FORM * form)
1328 |   
1329 |   Description   :  Move to the beginning of the next word in the field.
1330 |
1331 |   Return Values :  E_OK             - success
1332 |                    E_REQUEST_DENIED - there is no next word
1333 +--------------------------------------------------------------------------*/
1334 static int IFN_Next_Word(FORM * form)
1335 {
1336   FIELD *field = form->current;
1337   char  *bp    = Address_Of_Current_Position_In_Buffer(form);
1338   char  *s;
1339   char  *t;
1340
1341   /* We really need access to the data, so we have to synchronize */
1342   Synchronize_Buffer(form);
1343
1344   /* Go to the first whitespace after the current position (including
1345      current position). This is then the startpoint to look for the
1346     next non-blank data */
1347   s = Get_First_Whitespace_Character(bp,Buffer_Length(field) -
1348                                      (int)(bp - field->buf));
1349
1350   /* Find the start of the next word */
1351   t = Get_Start_Of_Data(s,Buffer_Length(field) -
1352                         (int)(s - field->buf));
1353 #if !FRIENDLY_PREV_NEXT_WORD
1354   if (s==t) 
1355     return(E_REQUEST_DENIED);
1356   else
1357 #endif
1358     {
1359       Adjust_Cursor_Position(form,t);
1360       return(E_OK);
1361     }
1362 }
1363
1364 /*---------------------------------------------------------------------------
1365 |   Facility      :  libnform  
1366 |   Function      :  static int IFN_Previous_Word(FORM * form)
1367 |   
1368 |   Description   :  Move to the beginning of the previous word in the field.
1369 |
1370 |   Return Values :  E_OK             - success
1371 |                    E_REQUEST_DENIED - there is no previous word
1372 +--------------------------------------------------------------------------*/
1373 static int IFN_Previous_Word(FORM * form)
1374 {
1375   FIELD *field = form->current;
1376   char  *bp    = Address_Of_Current_Position_In_Buffer(form);
1377   char  *s;
1378   char  *t;
1379   bool  again = FALSE;
1380
1381   /* We really need access to the data, so we have to synchronize */
1382   Synchronize_Buffer(form);
1383
1384   s = After_End_Of_Data(field->buf,(int)(bp-field->buf));
1385   /* s points now right after the last non-blank in the buffer before bp.
1386      If bp was in a word, s equals bp. In this case we must find the last
1387      whitespace in the buffer before bp and repeat the game to really find
1388      the previous word! */
1389   if (s==bp)
1390     again = TRUE;
1391   
1392   /* And next call now goes backward to look for the last whitespace
1393      before that, pointing right after this, so it points to the begin
1394      of the previous word. 
1395   */
1396   t = After_Last_Whitespace_Character(field->buf,(int)(s - field->buf));
1397 #if !FRIENDLY_PREV_NEXT_WORD
1398   if (s==t) 
1399     return(E_REQUEST_DENIED);
1400 #endif
1401   if (again)
1402     { /* and do it again, replacing bp by t */
1403       s = After_End_Of_Data(field->buf,(int)(t - field->buf));
1404       t = After_Last_Whitespace_Character(field->buf,(int)(s - field->buf));
1405 #if !FRIENDLY_PREV_NEXT_WORD
1406       if (s==t) 
1407         return(E_REQUEST_DENIED);
1408 #endif
1409     }
1410   Adjust_Cursor_Position(form,t);
1411   return(E_OK);
1412 }
1413
1414 /*---------------------------------------------------------------------------
1415 |   Facility      :  libnform  
1416 |   Function      :  static int IFN_Beginning_Of_Field(FORM * form)
1417 |   
1418 |   Description   :  Place the cursor at the first non-pad character in
1419 |                    the field. 
1420 |
1421 |   Return Values :  E_OK             - success            
1422 +--------------------------------------------------------------------------*/
1423 static int IFN_Beginning_Of_Field(FORM * form)
1424 {
1425   FIELD *field = form->current;
1426
1427   Synchronize_Buffer(form);
1428   Adjust_Cursor_Position(form,
1429                  Get_Start_Of_Data(field->buf,Buffer_Length(field)));
1430   return(E_OK);
1431 }
1432
1433 /*---------------------------------------------------------------------------
1434 |   Facility      :  libnform  
1435 |   Function      :  static int IFN_End_Of_Field(FORM * form)
1436 |   
1437 |   Description   :  Place the cursor after the last non-pad character in
1438 |                    the field. If the field occupies the last position in
1439 |                    the buffer, the cursos is positioned on the last 
1440 |                    character.
1441 |
1442 |   Return Values :  E_OK              - success
1443 +--------------------------------------------------------------------------*/
1444 static int IFN_End_Of_Field(FORM * form)
1445 {
1446   FIELD *field = form->current;
1447   char *pos;
1448
1449   Synchronize_Buffer(form);
1450   pos = After_End_Of_Data(field->buf,Buffer_Length(field));
1451   if (pos==(field->buf + Buffer_Length(field)))
1452     pos--;
1453   Adjust_Cursor_Position(form,pos);
1454   return(E_OK);
1455 }
1456
1457 /*---------------------------------------------------------------------------
1458 |   Facility      :  libnform  
1459 |   Function      :  static int IFN_Beginning_Of_Line(FORM * form)
1460 |   
1461 |   Description   :  Place the cursor on the first non-pad character in
1462 |                    the current line of the field.
1463 |
1464 |   Return Values :  E_OK         - success
1465 +--------------------------------------------------------------------------*/
1466 static int IFN_Beginning_Of_Line(FORM * form)
1467 {
1468   FIELD *field = form->current;
1469
1470   Synchronize_Buffer(form);
1471   Adjust_Cursor_Position(form,
1472                  Get_Start_Of_Data(Address_Of_Current_Row_In_Buffer(form),
1473                                    field->dcols));
1474   return(E_OK);
1475 }
1476
1477 /*---------------------------------------------------------------------------
1478 |   Facility      :  libnform  
1479 |   Function      :  static int IFN_End_Of_Line(FORM * form)
1480 |   
1481 |   Description   :  Place the cursor after the last non-pad character in the
1482 |                    current line of the field. If the field occupies the 
1483 |                    last column in the line, the cursor is positioned on the
1484 |                    last character of the line.
1485 |
1486 |   Return Values :  E_OK        - success
1487 +--------------------------------------------------------------------------*/
1488 static int IFN_End_Of_Line(FORM * form)
1489 {
1490   FIELD *field = form->current;
1491   char *pos;
1492   char *bp;
1493
1494   Synchronize_Buffer(form);
1495   bp  = Address_Of_Current_Row_In_Buffer(form); 
1496   pos = After_End_Of_Data(bp,field->dcols);
1497   if (pos == (bp + field->dcols))
1498     pos--;
1499   Adjust_Cursor_Position(form,pos);
1500   return(E_OK);
1501 }
1502
1503 /*---------------------------------------------------------------------------
1504 |   Facility      :  libnform  
1505 |   Function      :  static int IFN_Left_Character(FORM * form)
1506 |   
1507 |   Description   :  Move one character to the left in the current line.
1508 |                    This doesn't cycle.  
1509 |
1510 |   Return Values :  E_OK             - success
1511 |                    E_REQUEST_DENIED - already in first column
1512 +--------------------------------------------------------------------------*/
1513 static int IFN_Left_Character(FORM * form)
1514 {
1515   if ( (--(form->curcol)) < 0 )
1516     {
1517       form->curcol++;
1518       return(E_REQUEST_DENIED);
1519     }
1520   return(E_OK);
1521 }
1522
1523 /*---------------------------------------------------------------------------
1524 |   Facility      :  libnform  
1525 |   Function      :  static int IFN_Right_Character(FORM * form)
1526 |   
1527 |   Description   :  Move one character to the right in the current line.
1528 |                    This doesn't cycle.
1529 |
1530 |   Return Values :  E_OK              - success
1531 |                    E_REQUEST_DENIED  - already in last column
1532 +--------------------------------------------------------------------------*/
1533 static int IFN_Right_Character(FORM * form)
1534 {
1535   if ( (++(form->curcol)) == form->current->dcols )
1536     {
1537 #if GROW_IF_NAVIGATE
1538       FIELD *field = form->current;
1539       if (Single_Line_Field(field) && Field_Grown(field,1))
1540         return(E_OK);
1541 #endif
1542       --(form->curcol);
1543       return(E_REQUEST_DENIED);
1544     }
1545   return(E_OK);
1546 }
1547
1548 /*---------------------------------------------------------------------------
1549 |   Facility      :  libnform  
1550 |   Function      :  static int IFN_Up_Character(FORM * form)
1551 |   
1552 |   Description   :  Move one line up. This doesn't cycle through the lines
1553 |                    of the field.
1554 |
1555 |   Return Values :  E_OK              - success
1556 |                    E_REQUEST_DENIED  - already in last column
1557 +--------------------------------------------------------------------------*/
1558 static int IFN_Up_Character(FORM * form)
1559 {
1560   if ( (--(form->currow)) < 0 )
1561     {
1562       form->currow++;
1563       return(E_REQUEST_DENIED);
1564     }
1565   return(E_OK);
1566 }
1567
1568 /*---------------------------------------------------------------------------
1569 |   Facility      :  libnform  
1570 |   Function      :  static int IFN_Down_Character(FORM * form)
1571 |   
1572 |   Description   :  Move one line down. This doesn't cycle through the
1573 |                    lines of the field.
1574 |
1575 |   Return Values :  E_OK              - success
1576 |                    E_REQUEST_DENIED  - already in last column
1577 +--------------------------------------------------------------------------*/
1578 static int IFN_Down_Character(FORM * form)
1579 {
1580   FIELD *field = form->current;
1581
1582   if ( (++(form->currow)) == field->drows )
1583     {
1584 #if GROW_IF_NAVIGATE
1585       if (!Single_Line_Field(field) && Field_Grown(field,1))
1586         return(E_OK);
1587 #endif
1588       --(form->currow);
1589       return(E_REQUEST_DENIED);
1590     }
1591   return(E_OK);
1592 }
1593 /*----------------------------------------------------------------------------
1594   END of Intra-Field Navigation routines 
1595   --------------------------------------------------------------------------*/
1596 \f
1597 /*----------------------------------------------------------------------------
1598   Vertical scrolling helper routines
1599   --------------------------------------------------------------------------*/
1600
1601 /*---------------------------------------------------------------------------
1602 |   Facility      :  libnform  
1603 |   Function      :  static int VSC_Generic(FORM *form, int lines)
1604 |
1605 |   Description   :  Scroll multi-line field forward (lines>0) or
1606 |                    backward (lines<0) this many lines.
1607 |
1608 |   Return Values :  E_OK              - success 
1609 |                    E_REQUEST_DENIED  - can't scroll
1610 +--------------------------------------------------------------------------*/
1611 static int VSC_Generic(FORM *form, int lines)
1612 {
1613   FIELD *field = form->current;
1614   int res = E_REQUEST_DENIED;
1615   int rows_to_go = (lines > 0 ? lines : -lines);
1616
1617   if (lines > 0)
1618     {
1619       if ( (rows_to_go + form->toprow) > (field->drows - field->rows) )
1620         rows_to_go = (field->drows - field->rows - form->toprow);
1621
1622       if (rows_to_go > 0)
1623         {
1624           form->currow += rows_to_go;
1625           form->toprow += rows_to_go;
1626           res = E_OK;
1627         }
1628     }
1629   else
1630     {
1631       if (rows_to_go > form->toprow)
1632         rows_to_go = form->toprow;
1633       
1634       if (rows_to_go > 0)
1635         {
1636           form->currow -= rows_to_go;
1637           form->toprow -= rows_to_go;
1638           res = E_OK;
1639         }
1640     }
1641   return(res);
1642 }
1643 /*----------------------------------------------------------------------------
1644   End of Vertical scrolling helper routines
1645   --------------------------------------------------------------------------*/
1646 \f
1647 /*----------------------------------------------------------------------------
1648   Vertical scrolling routines
1649   --------------------------------------------------------------------------*/
1650
1651 /*---------------------------------------------------------------------------
1652 |   Facility      :  libnform  
1653 |   Function      :  static int Vertical_Scrolling(
1654 |                                           int (* const fct) (FORM *),
1655 |                                           FORM * form)
1656 |   
1657 |   Description   :  Performs the generic vertical scrolling routines. 
1658 |                    This has to check for a multi-line field and to set
1659 |                    the _NEWTOP flag if scrolling really occured.
1660 |
1661 |   Return Values :  Propagated error code from low-level driver calls
1662 +--------------------------------------------------------------------------*/
1663 static int Vertical_Scrolling(int (* const fct) (FORM *), FORM * form)
1664 {
1665   int res = E_REQUEST_DENIED;
1666
1667   if (!Single_Line_Field(form->current))
1668     {
1669       res = fct(form);
1670       if (res == E_OK)
1671         form->current->status |= _NEWTOP;
1672     }
1673   return(res);
1674 }
1675
1676 /*---------------------------------------------------------------------------
1677 |   Facility      :  libnform  
1678 |   Function      :  static int VSC_Scroll_Line_Forward(FORM * form)
1679 |   
1680 |   Description   :  Scroll multi-line field forward a line
1681 |
1682 |   Return Values :  E_OK                - success
1683 |                    E_REQUEST_DENIED    - no data ahead
1684 +--------------------------------------------------------------------------*/
1685 static int VSC_Scroll_Line_Forward(FORM * form)
1686 {
1687   return VSC_Generic(form,1);
1688 }
1689
1690 /*---------------------------------------------------------------------------
1691 |   Facility      :  libnform  
1692 |   Function      :  static int VSC_Scroll_Line_Backward(FORM * form)
1693 |   
1694 |   Description   :  Scroll multi-line field backward a line
1695 |
1696 |   Return Values :  E_OK                - success
1697 |                    E_REQUEST_DENIED    - no data behind
1698 +--------------------------------------------------------------------------*/
1699 static int VSC_Scroll_Line_Backward(FORM * form)
1700 {
1701   return VSC_Generic(form,-1);
1702 }
1703
1704 /*---------------------------------------------------------------------------
1705 |   Facility      :  libnform  
1706 |   Function      :  static int VSC_Scroll_Page_Forward(FORM * form)
1707 |   
1708 |   Description   :  Scroll a multi-line field forward a page
1709 |
1710 |   Return Values :  E_OK              - success
1711 |                    E_REQUEST_DENIED  - no data ahead
1712 +--------------------------------------------------------------------------*/
1713 static int VSC_Scroll_Page_Forward(FORM * form)
1714 {
1715   return VSC_Generic(form,form->current->rows);
1716 }
1717
1718 /*---------------------------------------------------------------------------
1719 |   Facility      :  libnform  
1720 |   Function      :  static int VSC_Scroll_Half_Page_Forward(FORM * form)
1721 |   
1722 |   Description   :  Scroll a multi-line field forward half a page
1723 |
1724 |   Return Values :  E_OK              - success
1725 |                    E_REQUEST_DENIED  - no data ahead
1726 +--------------------------------------------------------------------------*/
1727 static int VSC_Scroll_Half_Page_Forward(FORM * form)
1728 {
1729   return VSC_Generic(form,(form->current->rows + 1)/2);
1730 }
1731
1732 /*---------------------------------------------------------------------------
1733 |   Facility      :  libnform  
1734 |   Function      :  static int VSC_Scroll_Page_Backward(FORM * form)
1735 |   
1736 |   Description   :  Scroll a multi-line field backward a page
1737 |
1738 |   Return Values :  E_OK              - success
1739 |                    E_REQUEST_DENIED  - no data behind
1740 +--------------------------------------------------------------------------*/
1741 static int VSC_Scroll_Page_Backward(FORM * form)
1742 {
1743   return VSC_Generic(form, -(form->current->rows));
1744 }
1745
1746 /*---------------------------------------------------------------------------
1747 |   Facility      :  libnform  
1748 |   Function      :  static int VSC_Scroll_Half_Page_Backward(FORM * form)
1749 |   
1750 |   Description   :  Scroll a multi-line field backward half a page
1751 |
1752 |   Return Values :  E_OK              - success
1753 |                    E_REQUEST_DENIED  - no data behind
1754 +--------------------------------------------------------------------------*/
1755 static int VSC_Scroll_Half_Page_Backward(FORM * form)
1756 {
1757   return VSC_Generic(form, -((form->current->rows + 1)/2));
1758 }
1759 /*----------------------------------------------------------------------------
1760   End of Vertical scrolling routines
1761   --------------------------------------------------------------------------*/
1762 \f
1763 /*----------------------------------------------------------------------------
1764   Horizontal scrolling helper routines
1765   --------------------------------------------------------------------------*/
1766
1767 /*---------------------------------------------------------------------------
1768 |   Facility      :  libnform  
1769 |   Function      :  static int HSC_Generic(FORM *form, int columns)
1770 |
1771 |   Description   :  Scroll single-line field forward (columns>0) or
1772 |                    backward (columns<0) this many columns.
1773 |
1774 |   Return Values :  E_OK              - success 
1775 |                    E_REQUEST_DENIED  - can't scroll
1776 +--------------------------------------------------------------------------*/
1777 static int HSC_Generic(FORM *form, int columns)
1778 {
1779   FIELD *field = form->current;
1780   int res = E_REQUEST_DENIED;
1781   int cols_to_go = (columns > 0 ? columns : -columns);
1782
1783   if (columns > 0)
1784     {
1785       if ((cols_to_go + form->begincol) > (field->dcols - field->cols))
1786         cols_to_go = field->dcols - field->cols - form->begincol;
1787       
1788       if (cols_to_go > 0)
1789         {
1790           form->curcol   += cols_to_go;
1791           form->begincol += cols_to_go;
1792           res = E_OK;
1793         }
1794     }
1795   else
1796     {
1797       if ( cols_to_go > form->begincol )
1798         cols_to_go = form->begincol;
1799
1800       if (cols_to_go > 0)
1801         {
1802           form->curcol   -= cols_to_go;
1803           form->begincol -= cols_to_go;
1804           res = E_OK;
1805         }
1806     }
1807   return(res);
1808 }
1809 /*----------------------------------------------------------------------------
1810   End of Horizontal scrolling helper routines
1811   --------------------------------------------------------------------------*/
1812 \f
1813 /*----------------------------------------------------------------------------
1814   Horizontal scrolling routines
1815   --------------------------------------------------------------------------*/
1816
1817 /*---------------------------------------------------------------------------
1818 |   Facility      :  libnform  
1819 |   Function      :  static int Horizontal_Scrolling(
1820 |                                          int (* const fct) (FORM *),
1821 |                                          FORM * form)
1822 |   
1823 |   Description   :  Performs the generic horizontal scrolling routines. 
1824 |                    This has to check for a single-line field.
1825 |
1826 |   Return Values :  Propagated error code from low-level driver calls
1827 +--------------------------------------------------------------------------*/
1828 static int Horizontal_Scrolling(int (* const fct) (FORM *), FORM * form)
1829 {
1830   if (Single_Line_Field(form->current))
1831     return fct(form);
1832   else
1833     return(E_REQUEST_DENIED);
1834 }
1835
1836 /*---------------------------------------------------------------------------
1837 |   Facility      :  libnform  
1838 |   Function      :  static int HSC_Scroll_Char_Forward(FORM * form)
1839 |   
1840 |   Description   :  Scroll single-line field forward a character
1841 |
1842 |   Return Values :  E_OK                - success
1843 |                    E_REQUEST_DENIED    - no data ahead
1844 +--------------------------------------------------------------------------*/
1845 static int HSC_Scroll_Char_Forward(FORM *form)
1846 {
1847   return HSC_Generic(form,1);
1848 }
1849
1850 /*---------------------------------------------------------------------------
1851 |   Facility      :  libnform  
1852 |   Function      :  static int HSC_Scroll_Char_Backward(FORM * form)
1853 |   
1854 |   Description   :  Scroll single-line field backward a character
1855 |
1856 |   Return Values :  E_OK                - success
1857 |                    E_REQUEST_DENIED    - no data behind
1858 +--------------------------------------------------------------------------*/
1859 static int HSC_Scroll_Char_Backward(FORM *form)
1860 {
1861   return HSC_Generic(form,-1);
1862 }
1863
1864 /*---------------------------------------------------------------------------
1865 |   Facility      :  libnform  
1866 |   Function      :  static int HSC_Horizontal_Line_Forward(FORM* form)
1867 |   
1868 |   Description   :  Scroll single-line field forward a line
1869 |
1870 |   Return Values :  E_OK                - success
1871 |                    E_REQUEST_DENIED    - no data ahead
1872 +--------------------------------------------------------------------------*/
1873 static int HSC_Horizontal_Line_Forward(FORM * form)
1874 {
1875   return HSC_Generic(form,form->current->cols);
1876 }
1877
1878 /*---------------------------------------------------------------------------
1879 |   Facility      :  libnform  
1880 |   Function      :  static int HSC_Horizontal_Half_Line_Forward(FORM* form)
1881 |   
1882 |   Description   :  Scroll single-line field forward half a line
1883 |
1884 |   Return Values :  E_OK               - success
1885 |                    E_REQUEST_DENIED   - no data ahead
1886 +--------------------------------------------------------------------------*/
1887 static int HSC_Horizontal_Half_Line_Forward(FORM * form)
1888 {
1889   return HSC_Generic(form,(form->current->cols + 1)/2);
1890 }
1891
1892 /*---------------------------------------------------------------------------
1893 |   Facility      :  libnform  
1894 |   Function      :  static int HSC_Horizontal_Line_Backward(FORM* form)
1895 |   
1896 |   Description   :  Scroll single-line field backward a line
1897 |
1898 |   Return Values :  E_OK                - success
1899 |                    E_REQUEST_DENIED    - no data behind
1900 +--------------------------------------------------------------------------*/
1901 static int HSC_Horizontal_Line_Backward(FORM * form)
1902 {
1903   return HSC_Generic(form,-(form->current->cols));
1904 }
1905
1906 /*---------------------------------------------------------------------------
1907 |   Facility      :  libnform  
1908 |   Function      :  static int HSC_Horizontal_Half_Line_Backward(FORM* form)
1909 |   
1910 |   Description   :  Scroll single-line field backward half a line
1911 |
1912 |   Return Values :  E_OK                - success
1913 |                    E_REQUEST_DENIED    - no data behind
1914 +--------------------------------------------------------------------------*/
1915 static int HSC_Horizontal_Half_Line_Backward(FORM * form)
1916 {
1917   return HSC_Generic(form,-((form->current->cols + 1)/2));
1918 }
1919
1920 /*----------------------------------------------------------------------------
1921   End of Horizontal scrolling routines
1922   --------------------------------------------------------------------------*/
1923 \f
1924 /*----------------------------------------------------------------------------
1925   Helper routines for Field Editing
1926   --------------------------------------------------------------------------*/
1927
1928 /*---------------------------------------------------------------------------
1929 |   Facility      :  libnform  
1930 |   Function      :  static bool Is_There_Room_For_A_Line(FORM * form)
1931 |   
1932 |   Description   :  Check whether or not there is enough room in the
1933 |                    buffer to enter a whole line.
1934 |
1935 |   Return Values :  TRUE   - there is enough space
1936 |                    FALSE  - there is not enough space
1937 +--------------------------------------------------------------------------*/
1938 INLINE static bool Is_There_Room_For_A_Line(FORM * form)
1939 {
1940   FIELD *field = form->current;
1941   char *begin_of_last_line, *s;
1942   
1943   Synchronize_Buffer(form);
1944   begin_of_last_line = Address_Of_Row_In_Buffer(field,(field->drows-1));
1945   s  = After_End_Of_Data(begin_of_last_line,field->dcols);
1946   return ((s==begin_of_last_line) ? TRUE : FALSE);
1947 }
1948
1949 /*---------------------------------------------------------------------------
1950 |   Facility      :  libnform  
1951 |   Function      :  static bool Is_There_Room_For_A_Char_In_Line(FORM * form)
1952 |   
1953 |   Description   :  Checks whether or not there is room for a new character
1954 |                    in the current line.
1955 |
1956 |   Return Values :  TRUE    - there is room
1957 |                    FALSE   - there is not enough room (line full)
1958 +--------------------------------------------------------------------------*/
1959 INLINE static bool Is_There_Room_For_A_Char_In_Line(FORM * form)
1960 {
1961   int last_char_in_line;
1962
1963   wmove(form->w,form->currow,form->current->dcols-1);
1964   last_char_in_line  = (int)(winch(form->w) & A_CHARTEXT);
1965   wmove(form->w,form->currow,form->curcol);
1966   return (((last_char_in_line == form->current->pad) ||
1967            is_blank(last_char_in_line)) ? TRUE : FALSE);
1968 }
1969
1970 #define There_Is_No_Room_For_A_Char_In_Line(f) \
1971   !Is_There_Room_For_A_Char_In_Line(f)
1972
1973 /*---------------------------------------------------------------------------
1974 |   Facility      :  libnform  
1975 |   Function      :  static int Insert_String(
1976 |                                             FORM * form,
1977 |                                             int row,
1978 |                                             char *txt,
1979 |                                             int  len )
1980 |   
1981 |   Description   :  Insert the 'len' characters beginning at pointer 'txt'
1982 |                    into the 'row' of the 'form'. The insertion occurs
1983 |                    on the beginning of the row, all other characters are
1984 |                    moved to the right. After the text a pad character will 
1985 |                    be inserted to separate the text from the rest. If
1986 |                    necessary the insertion moves characters on the next
1987 |                    line to make place for the requested insertion string.
1988 |
1989 |   Return Values :  E_OK              - success 
1990 |                    E_REQUEST_DENIED  -
1991 |                    E_SYSTEM_ERROR    - system error
1992 +--------------------------------------------------------------------------*/
1993 static int Insert_String(FORM *form, int row, char *txt, int len)
1994
1995   FIELD  *field    = form->current;
1996   char *bp         = Address_Of_Row_In_Buffer(field,row);
1997   int datalen      = (int)(After_End_Of_Data(bp,field->dcols) - bp);
1998   int freelen      = field->dcols - datalen;
1999   int requiredlen  = len+1;
2000   char *split;
2001   int result = E_REQUEST_DENIED;
2002   const char *Space = " ";
2003
2004   if (freelen >= requiredlen)
2005     {
2006       wmove(form->w,row,0);
2007       winsnstr(form->w,txt,len);
2008       wmove(form->w,row,len);
2009       winsnstr(form->w,Space,1);
2010       return E_OK;
2011     }
2012   else
2013     { /* we have to move characters on the next line. If we are on the
2014          last line this may work, if the field is growable */
2015       if ((row == (field->drows - 1)) && Growable(field))
2016         {
2017           if (!Field_Grown(field,1))
2018             return(E_SYSTEM_ERROR);
2019           /* !!!Side-Effect : might be changed due to growth!!! */
2020           bp = Address_Of_Row_In_Buffer(field,row); 
2021         }
2022
2023       if (row < (field->drows - 1)) 
2024         { 
2025           split = After_Last_Whitespace_Character(bp,
2026                     (int)(Get_Start_Of_Data(bp + field->dcols - requiredlen ,
2027                                             requiredlen) - bp));
2028           /* split points now to the first character of the portion of the
2029              line that must be moved to the next line */
2030           datalen = (int)(split-bp); /* + freelen has to stay on this line   */
2031           freelen = field->dcols - (datalen + freelen); /* for the next line */
2032
2033           if ((result=Insert_String(form,row+1,split,freelen))==E_OK) 
2034             {
2035               wmove(form->w,row,datalen);
2036               wclrtoeol(form->w);
2037               wmove(form->w,row,0);
2038               winsnstr(form->w,txt,len);
2039               wmove(form->w,row,len);
2040               winsnstr(form->w,Space,1);
2041               return E_OK;
2042             }
2043         }
2044       return(result);
2045     }
2046 }
2047
2048 /*---------------------------------------------------------------------------
2049 |   Facility      :  libnform  
2050 |   Function      :  static int Wrapping_Not_Necessary_Or_Wrapping_Ok(
2051 |                                             FORM * form)
2052 |   
2053 |   Description   :  If a character has been entered into a field, it may
2054 |                    be that wrapping has to occur. This routine checks
2055 |                    whether or not wrapping is required and if so, performs
2056 |                    the wrapping.
2057 |
2058 |   Return Values :  E_OK              - no wrapping required or wrapping
2059 |                                        was successfull
2060 |                    E_REQUEST_DENIED  -
2061 |                    E_SYSTEM_ERROR    - some system error
2062 +--------------------------------------------------------------------------*/
2063 static int Wrapping_Not_Necessary_Or_Wrapping_Ok(FORM * form)
2064 {
2065   FIELD  *field = form->current;
2066   int result = E_REQUEST_DENIED;
2067   bool Last_Row = ((field->drows - 1) == form->currow);
2068
2069   if ( (field->opts & O_WRAP)                     &&  /* wrapping wanted     */
2070       (!Single_Line_Field(field))                 &&  /* must be multi-line  */
2071       (There_Is_No_Room_For_A_Char_In_Line(form)) &&  /* line is full        */
2072       (!Last_Row || Growable(field))               )  /* there are more lines*/
2073     {
2074       char *bp;
2075       char *split;
2076       int chars_to_be_wrapped;
2077       int chars_to_remain_on_line;
2078       if (Last_Row)
2079         { /* the above logic already ensures, that in this case the field
2080              is growable */
2081           if (!Field_Grown(field,1))
2082             return E_SYSTEM_ERROR;
2083         }
2084       bp = Address_Of_Current_Row_In_Buffer(form);
2085       Window_To_Buffer(form->w,field);
2086       split = After_Last_Whitespace_Character(bp,field->dcols);
2087       /* split points to the first character of the sequence to be brought
2088          on the next line */
2089       chars_to_remain_on_line = (int)(split - bp);
2090       chars_to_be_wrapped     = field->dcols - chars_to_remain_on_line;
2091       if (chars_to_remain_on_line > 0)
2092         {
2093           if ((result=Insert_String(form,form->currow+1,split,
2094                                     chars_to_be_wrapped)) == E_OK)
2095             {
2096               wmove(form->w,form->currow,chars_to_remain_on_line);
2097               wclrtoeol(form->w);
2098               if (form->curcol >= chars_to_remain_on_line)
2099                 {
2100                   form->currow++;
2101                   form->curcol -= chars_to_remain_on_line;
2102                 }
2103               return E_OK;
2104             }
2105         }
2106       else
2107         return E_OK;
2108       if (result!=E_OK)
2109         {
2110           wmove(form->w,form->currow,form->curcol);
2111           wdelch(form->w);
2112           Window_To_Buffer(form->w,field);
2113           result = E_REQUEST_DENIED;
2114         }
2115     }
2116   else
2117     result = E_OK; /* wrapping was not necessary */
2118   return(result);
2119 }
2120 \f
2121 /*----------------------------------------------------------------------------
2122   Field Editing routines
2123   --------------------------------------------------------------------------*/
2124
2125 /*---------------------------------------------------------------------------
2126 |   Facility      :  libnform  
2127 |   Function      :  static int Field_Editing(
2128 |                                    int (* const fct) (FORM *),
2129 |                                    FORM * form)
2130 |   
2131 |   Description   :  Generic routine for field editing requests. The driver
2132 |                    routines are only called for editable fields, the
2133 |                    _WINDOW_MODIFIED flag is set if editing occured.
2134 |                    This is somewhat special due to the overload semantics
2135 |                    of the NEW_LINE and DEL_PREV requests.
2136 |
2137 |   Return Values :  Error code from low level drivers.
2138 +--------------------------------------------------------------------------*/
2139 static int Field_Editing(int (* const fct) (FORM *), FORM * form)
2140 {
2141   int res = E_REQUEST_DENIED;
2142
2143   /* We have to deal here with the specific case of the overloaded 
2144      behaviour of New_Line and Delete_Previous requests.
2145      They may end up in navigational requests if we are on the first
2146      character in a field. But navigation is also allowed on non-
2147      editable fields.
2148   */ 
2149   if ((fct==FE_Delete_Previous)            && 
2150       (form->opts & O_BS_OVERLOAD)         &&
2151       First_Position_In_Current_Field(form) )
2152     {
2153       res = Inter_Field_Navigation(FN_Previous_Field,form);
2154     }
2155   else
2156     {
2157       if (fct==FE_New_Line)
2158         {
2159           if ((form->opts & O_NL_OVERLOAD)         &&
2160               First_Position_In_Current_Field(form))
2161             {
2162               res = Inter_Field_Navigation(FN_Next_Field,form);
2163             }
2164           else
2165             /* FE_New_Line deals itself with the _WINDOW_MODIFIED flag */
2166             res = fct(form);
2167         }
2168       else
2169         {
2170           /* From now on, everything must be editable */
2171           if (form->current->opts & O_EDIT)
2172             {
2173               res = fct(form);
2174               if (res==E_OK)
2175                 form->status |= _WINDOW_MODIFIED;
2176             }
2177         }
2178     }
2179   return res;
2180 }
2181
2182 /*---------------------------------------------------------------------------
2183 |   Facility      :  libnform  
2184 |   Function      :  static int FE_New_Line(FORM * form)
2185 |   
2186 |   Description   :  Perform a new line request. This is rather complex
2187 |                    compared to other routines in this code due to the 
2188 |                    rather difficult to understand description in the
2189 |                    manuals.
2190 |
2191 |   Return Values :  E_OK               - success
2192 |                    E_REQUEST_DENIED   - new line not allowed
2193 |                    E_SYSTEM_ERROR     - system error
2194 +--------------------------------------------------------------------------*/
2195 static int FE_New_Line(FORM * form)
2196 {
2197   FIELD  *field = form->current;
2198   char *bp, *t;
2199   bool Last_Row = ((field->drows - 1)==form->currow);
2200   
2201   if (form->status & _OVLMODE) 
2202     {
2203       if (Last_Row && 
2204           (!(Growable(field) && !Single_Line_Field(field))))
2205         {
2206           if (!(form->opts & O_NL_OVERLOAD))
2207             return(E_REQUEST_DENIED);
2208           wclrtoeol(form->w);
2209           /* we have to set this here, although it is also
2210              handled in the generic routine. The reason is,
2211              that FN_Next_Field may fail, but the form is
2212              definitively changed */
2213           form->status |= _WINDOW_MODIFIED;
2214           return Inter_Field_Navigation(FN_Next_Field,form);
2215         }
2216       else 
2217         {
2218           if (Last_Row && !Field_Grown(field,1))
2219             { /* N.B.: due to the logic in the 'if', LastRow==TRUE
2220                  means here that the field is growable and not
2221                  a single-line field */
2222               return(E_SYSTEM_ERROR);
2223             }
2224           wclrtoeol(form->w);
2225           form->currow++;
2226           form->curcol = 0;
2227           form->status |= _WINDOW_MODIFIED;
2228           return(E_OK);
2229         }
2230     }
2231   else 
2232     { /* Insert Mode */
2233       if (Last_Row &&
2234           !(Growable(field) && !Single_Line_Field(field)))
2235         {
2236           if (!(form->opts & O_NL_OVERLOAD))
2237             return(E_REQUEST_DENIED);
2238           return Inter_Field_Navigation(FN_Next_Field,form);
2239         }
2240       else 
2241         {
2242           bool May_Do_It = !Last_Row && Is_There_Room_For_A_Line(form);
2243           
2244           if (!(May_Do_It || Growable(field)))
2245             return(E_REQUEST_DENIED);
2246           if (!May_Do_It && !Field_Grown(field,1))
2247             return(E_SYSTEM_ERROR);
2248           
2249           bp= Address_Of_Current_Position_In_Buffer(form);
2250           t = After_End_Of_Data(bp,field->dcols - form->curcol);
2251           wclrtoeol(form->w);
2252           form->currow++;
2253           form->curcol=0;
2254           wmove(form->w,form->currow,form->curcol);
2255           winsertln(form->w);
2256           waddnstr(form->w,bp,(int)(t-bp));
2257           form->status |= _WINDOW_MODIFIED;
2258           return E_OK;
2259         }
2260     }
2261 }
2262
2263 /*---------------------------------------------------------------------------
2264 |   Facility      :  libnform  
2265 |   Function      :  static int FE_Insert_Character(FORM * form)
2266 |   
2267 |   Description   :  Insert blank character at the cursor position
2268 |
2269 |   Return Values :  E_OK
2270 |                    E_REQUEST_DENIED
2271 +--------------------------------------------------------------------------*/
2272 static int FE_Insert_Character(FORM * form)
2273 {
2274   FIELD *field = form->current;
2275   int result = E_REQUEST_DENIED;
2276
2277   if (Check_Char(field->type,(int)C_BLANK,(TypeArgument *)(field->arg)))
2278     {
2279       bool There_Is_Room = Is_There_Room_For_A_Char_In_Line(form);
2280
2281       if (There_Is_Room ||
2282           ((Single_Line_Field(field) && Growable(field))))
2283         {
2284           if (!There_Is_Room && !Field_Grown(field,1))
2285             result =  E_SYSTEM_ERROR;
2286           else
2287             {
2288               winsch(form->w,(chtype)C_BLANK);
2289               result = Wrapping_Not_Necessary_Or_Wrapping_Ok(form);
2290             }
2291         }
2292     }
2293   return result;
2294 }
2295
2296 /*---------------------------------------------------------------------------
2297 |   Facility      :  libnform  
2298 |   Function      :  static int FE_Insert_Line(FORM * form)
2299 |   
2300 |   Description   :  Insert a blank line at the cursor position
2301 |
2302 |   Return Values :  E_OK               - success
2303 |                    E_REQUEST_DENIED   - line can not be inserted
2304 +--------------------------------------------------------------------------*/
2305 static int FE_Insert_Line(FORM * form)
2306 {
2307   FIELD *field = form->current;
2308   int result = E_REQUEST_DENIED;
2309
2310   if (Check_Char(field->type,(int)C_BLANK,(TypeArgument *)(field->arg)))
2311     {
2312       bool Maybe_Done = (form->currow!=(field->drows-1)) && 
2313                         Is_There_Room_For_A_Line(form);
2314
2315       if (!Single_Line_Field(field) &&
2316           (Maybe_Done || Growable(field)))
2317         {
2318           if (!Maybe_Done && !Field_Grown(field,1))
2319             result = E_SYSTEM_ERROR;
2320           else
2321             {
2322               form->curcol = 0;
2323               winsertln(form->w);
2324               result = E_OK;
2325             }
2326         }
2327     }
2328   return result;
2329 }
2330
2331 /*---------------------------------------------------------------------------
2332 |   Facility      :  libnform  
2333 |   Function      :  static int FE_Delete_Character(FORM * form)
2334 |   
2335 |   Description   :  Delete character at the cursor position
2336 |
2337 |   Return Values :  E_OK    - success
2338 +--------------------------------------------------------------------------*/
2339 static int FE_Delete_Character(FORM * form)
2340 {
2341   wdelch(form->w);
2342   return E_OK;
2343 }
2344
2345 /*---------------------------------------------------------------------------
2346 |   Facility      :  libnform  
2347 |   Function      :  static int FE_Delete_Previous(FORM * form)
2348 |   
2349 |   Description   :  Delete character before cursor. Again this is a rather
2350 |                    difficult piece compared to others due to the overloading
2351 |                    semantics of backspace.
2352 |                    N.B.: The case of overloaded BS on first field position
2353 |                          is already handled in the generic routine.
2354 |
2355 |   Return Values :  E_OK                - success
2356 |                    E_REQUEST_DENIED    - Character can't be deleted
2357 +--------------------------------------------------------------------------*/
2358 static int FE_Delete_Previous(FORM * form)
2359 {
2360   FIELD  *field = form->current;
2361   
2362   if (First_Position_In_Current_Field(form))
2363     return E_REQUEST_DENIED;
2364
2365   if ( (--(form->curcol))<0 )
2366     {
2367       char *this_line, *prev_line, *prev_end, *this_end;
2368       
2369       form->curcol++;
2370       if (form->status & _OVLMODE) 
2371         return E_REQUEST_DENIED;
2372       
2373       prev_line = Address_Of_Row_In_Buffer(field,(form->currow-1));
2374       this_line = Address_Of_Row_In_Buffer(field,(form->currow));
2375       Synchronize_Buffer(form);
2376       prev_end = After_End_Of_Data(prev_line,field->dcols);
2377       this_end = After_End_Of_Data(this_line,field->dcols);
2378       if ((int)(this_end-this_line) > 
2379           (field->cols-(int)(prev_end-prev_line))) 
2380         return E_REQUEST_DENIED;
2381       wdeleteln(form->w);
2382       Adjust_Cursor_Position(form,prev_end);
2383       wmove(form->w,form->currow,form->curcol);
2384       waddnstr(form->w,this_line,(int)(this_end-this_line));
2385     } 
2386   else 
2387     {
2388       wmove(form->w,form->currow,form->curcol);
2389       wdelch(form->w);
2390     }
2391   return E_OK;
2392 }
2393
2394 /*---------------------------------------------------------------------------
2395 |   Facility      :  libnform  
2396 |   Function      :  static int FE_Delete_Line(FORM * form)
2397 |   
2398 |   Description   :  Delete line at cursor position.
2399 |
2400 |   Return Values :  E_OK  - success
2401 +--------------------------------------------------------------------------*/
2402 static int FE_Delete_Line(FORM * form)
2403 {
2404   form->curcol = 0;
2405   wdeleteln(form->w);
2406   return E_OK;
2407 }
2408
2409 /*---------------------------------------------------------------------------
2410 |   Facility      :  libnform  
2411 |   Function      :  static int FE_Delete_Word(FORM * form)
2412 |   
2413 |   Description   :  Delete word at cursor position
2414 |
2415 |   Return Values :  E_OK               - success
2416 |                    E_REQUEST_DENIED   - failure
2417 +--------------------------------------------------------------------------*/
2418 static int FE_Delete_Word(FORM * form)
2419 {
2420   FIELD  *field = form->current;
2421   char   *bp = Address_Of_Current_Row_In_Buffer(form);
2422   char   *ep = bp + field->dcols;
2423   char   *cp = bp + form->curcol;
2424   char *s;
2425   
2426   Synchronize_Buffer(form);
2427   if (is_blank(*cp)) 
2428     return E_REQUEST_DENIED; /* not in word */
2429
2430   /* move cursor to begin of word and erase to end of screen-line */
2431   Adjust_Cursor_Position(form,
2432                          After_Last_Whitespace_Character(bp,form->curcol)); 
2433   wmove(form->w,form->currow,form->curcol);
2434   wclrtoeol(form->w);
2435
2436   /* skip over word in buffer */
2437   s = Get_First_Whitespace_Character(cp,(int)(ep-cp)); 
2438   /* to begin of next word    */
2439   s = Get_Start_Of_Data(s,(int)(ep - s));
2440   if ( (s!=cp) && !is_blank(*s))
2441     {
2442       /* copy remaining line to window */
2443       waddnstr(form->w,s,(int)(s - After_End_Of_Data(s,(int)(ep - s))));
2444     }
2445   return E_OK;
2446 }
2447
2448 /*---------------------------------------------------------------------------
2449 |   Facility      :  libnform  
2450 |   Function      :  static int FE_Clear_To_End_Of_Line(FORM * form)
2451 |   
2452 |   Description   :  Clear to end of current line.
2453 |
2454 |   Return Values :  E_OK   - success
2455 +--------------------------------------------------------------------------*/
2456 static int FE_Clear_To_End_Of_Line(FORM * form)
2457 {
2458   wclrtoeol(form->w);
2459   return E_OK;
2460 }
2461
2462 /*---------------------------------------------------------------------------
2463 |   Facility      :  libnform  
2464 |   Function      :  static int FE_Clear_To_End_Of_Form(FORM * form)
2465 |   
2466 |   Description   :  Clear to end of form.
2467 |
2468 |   Return Values :  E_OK   - success
2469 +--------------------------------------------------------------------------*/
2470 static int FE_Clear_To_End_Of_Form(FORM * form)
2471 {
2472   wclrtobot(form->w);
2473   return E_OK;
2474 }
2475
2476 /*---------------------------------------------------------------------------
2477 |   Facility      :  libnform  
2478 |   Function      :  static int FE_Clear_Field(FORM * form)
2479 |   
2480 |   Description   :  Clear entire field.
2481 |
2482 |   Return Values :  E_OK   - success
2483 +--------------------------------------------------------------------------*/
2484 static int FE_Clear_Field(FORM * form)
2485 {
2486   form->currow = form->curcol = 0;
2487   werase(form->w);
2488   return E_OK;
2489 }
2490 /*----------------------------------------------------------------------------
2491   END of Field Editing routines 
2492   --------------------------------------------------------------------------*/
2493 \f
2494 /*----------------------------------------------------------------------------
2495   Edit Mode routines
2496   --------------------------------------------------------------------------*/
2497
2498 /*---------------------------------------------------------------------------
2499 |   Facility      :  libnform  
2500 |   Function      :  static int EM_Overlay_Mode(FORM * form)
2501 |   
2502 |   Description   :  Switch to overlay mode.
2503 |
2504 |   Return Values :  E_OK   - success
2505 +--------------------------------------------------------------------------*/
2506 static int EM_Overlay_Mode(FORM * form)
2507 {
2508   form->status |= _OVLMODE;
2509   return E_OK;
2510 }
2511
2512 /*---------------------------------------------------------------------------
2513 |   Facility      :  libnform  
2514 |   Function      :  static int EM_Insert_Mode(FORM * form)
2515 |   
2516 |   Description   :  Switch to insert mode
2517 |
2518 |   Return Values :  E_OK   - success
2519 +--------------------------------------------------------------------------*/
2520 static int EM_Insert_Mode(FORM * form)
2521 {
2522   form->status &= ~_OVLMODE;
2523   return E_OK;
2524 }
2525
2526 /*----------------------------------------------------------------------------
2527   END of Edit Mode routines 
2528   --------------------------------------------------------------------------*/
2529 \f
2530 /*----------------------------------------------------------------------------
2531   Helper routines for Choice Requests
2532   --------------------------------------------------------------------------*/
2533
2534 /*---------------------------------------------------------------------------
2535 |   Facility      :  libnform  
2536 |   Function      :  static bool Next_Choice(
2537 |                                            FIELDTYPE * typ,
2538 |                                            FIELD * field,
2539 |                                            TypeArgument *argp)
2540 |   
2541 |   Description   :  Get the next field choice. For linked types this is
2542 |                    done recursively.
2543 |
2544 |   Return Values :  TRUE    - next choice successfully retrieved
2545 |                    FALSE   - couldn't retrieve next choice
2546 +--------------------------------------------------------------------------*/
2547 static bool Next_Choice(FIELDTYPE * typ, FIELD *field, TypeArgument *argp)
2548 {
2549   if (!typ || !(typ->status & _HAS_CHOICE)) 
2550     return FALSE;
2551
2552   if (typ->status & _LINKED_TYPE)
2553     {
2554       assert(argp);
2555       return(
2556              Next_Choice(typ->left ,field,argp->left) ||
2557              Next_Choice(typ->right,field,argp->right) );
2558     } 
2559   else
2560     {
2561       assert(typ->next);
2562       return typ->next(field,(void *)argp);
2563     }
2564 }
2565
2566 /*---------------------------------------------------------------------------
2567 |   Facility      :  libnform  
2568 |   Function      :  static bool Previous_Choice(
2569 |                                                FIELDTYPE * typ,
2570 |                                                FIELD * field,
2571 |                                                TypeArgument *argp)
2572 |   
2573 |   Description   :  Get the previous field choice. For linked types this
2574 |                    is done recursively.
2575 |
2576 |   Return Values :  TRUE    - previous choice successfully retrieved
2577 |                    FALSE   - couldn't retrieve previous choice
2578 +--------------------------------------------------------------------------*/
2579 static bool Previous_Choice(FIELDTYPE *typ, FIELD *field, TypeArgument *argp)
2580 {
2581   if (!typ || !(typ->status & _HAS_CHOICE)) 
2582     return FALSE;
2583
2584   if (typ->status & _LINKED_TYPE)
2585     {
2586       assert(argp);
2587       return(
2588              Previous_Choice(typ->left ,field,argp->left) ||
2589              Previous_Choice(typ->right,field,argp->right));
2590     } 
2591   else 
2592     {
2593       assert(typ->prev);
2594       return typ->prev(field,(void *)argp);
2595     }
2596 }
2597 /*----------------------------------------------------------------------------
2598   End of Helper routines for Choice Requests
2599   --------------------------------------------------------------------------*/
2600 \f
2601 /*----------------------------------------------------------------------------
2602   Routines for Choice Requests
2603   --------------------------------------------------------------------------*/
2604
2605 /*---------------------------------------------------------------------------
2606 |   Facility      :  libnform  
2607 |   Function      :  static int CR_Next_Choice(FORM * form)
2608 |   
2609 |   Description   :  Get the next field choice.
2610 |
2611 |   Return Values :  E_OK              - success
2612 |                    E_REQUEST_DENIED  - next choice couldn't be retrieved
2613 +--------------------------------------------------------------------------*/
2614 static int CR_Next_Choice(FORM * form)
2615 {
2616   FIELD *field = form->current;
2617   Synchronize_Buffer(form);
2618   return ((Next_Choice(field->type,field,(TypeArgument *)(field->arg))) ? 
2619           E_OK : E_REQUEST_DENIED);
2620 }
2621
2622 /*---------------------------------------------------------------------------
2623 |   Facility      :  libnform  
2624 |   Function      :  static int CR_Previous_Choice(FORM * form)
2625 |   
2626 |   Description   :  Get the previous field choice.
2627 |
2628 |   Return Values :  E_OK              - success
2629 |                    E_REQUEST_DENIED  - prev. choice couldn't be retrieved
2630 +--------------------------------------------------------------------------*/
2631 static int CR_Previous_Choice(FORM * form)
2632 {
2633   FIELD *field = form->current;
2634   Synchronize_Buffer(form);
2635   return ((Previous_Choice(field->type,field,(TypeArgument *)(field->arg))) ? 
2636           E_OK : E_REQUEST_DENIED);
2637 }
2638 /*----------------------------------------------------------------------------
2639   End of Routines for Choice Requests
2640   --------------------------------------------------------------------------*/
2641 \f
2642 /*----------------------------------------------------------------------------
2643   Helper routines for Field Validations.
2644   --------------------------------------------------------------------------*/
2645
2646 /*---------------------------------------------------------------------------
2647 |   Facility      :  libnform  
2648 |   Function      :  static bool Check_Field(
2649 |                                            FIELDTYPE * typ,
2650 |                                            FIELD * field,
2651 |                                            TypeArgument * argp)
2652 |   
2653 |   Description   :  Check the field according to its fieldtype and its
2654 |                    actual arguments. For linked fieldtypes this is done
2655 |                    recursively.
2656 |
2657 |   Return Values :  TRUE       - field is valid
2658 |                    FALSE      - field is invalid.
2659 +--------------------------------------------------------------------------*/
2660 static bool Check_Field(FIELDTYPE *typ, FIELD *field, TypeArgument *argp)
2661 {
2662   if (typ)
2663     {
2664       if (field->opts & O_NULLOK)
2665         {
2666           char *bp = field->buf;
2667           assert(bp);
2668           while(is_blank(*bp))
2669             { bp++; }
2670           if (*bp == '\0') 
2671             return TRUE;
2672         }
2673
2674       if (typ->status & _LINKED_TYPE)
2675         {
2676           assert(argp);
2677           return( 
2678                  Check_Field(typ->left ,field,argp->left ) ||
2679                  Check_Field(typ->right,field,argp->right) );
2680         }
2681       else 
2682         {
2683           if (typ->fcheck)
2684             return typ->fcheck(field,(void *)argp);
2685         }
2686     }
2687   return TRUE;
2688 }
2689
2690 /*---------------------------------------------------------------------------
2691 |   Facility      :  libnform  
2692 |   Function      :  bool _nc_Internal_Validation(FORM * form )
2693 |   
2694 |   Description   :  Validate the current field of the form.  
2695 |
2696 |   Return Values :  TRUE  - field is valid
2697 |                    FALSE - field is invalid
2698 +--------------------------------------------------------------------------*/
2699 NCURSES_EXPORT(bool)
2700 _nc_Internal_Validation (FORM *form)
2701 {
2702   FIELD *field;
2703
2704   field = form->current; 
2705   
2706   Synchronize_Buffer(form);
2707   if ((form->status & _FCHECK_REQUIRED) ||
2708       (!(field->opts & O_PASSOK)))
2709     {
2710       if (!Check_Field(field->type,field,(TypeArgument *)(field->arg)))
2711         return FALSE;
2712       form->status  &= ~_FCHECK_REQUIRED;
2713       field->status |= _CHANGED;
2714       Synchronize_Linked_Fields(field);
2715     }
2716   return TRUE;
2717 }
2718 /*----------------------------------------------------------------------------
2719   End of Helper routines for Field Validations.
2720   --------------------------------------------------------------------------*/
2721 \f
2722 /*----------------------------------------------------------------------------
2723   Routines for Field Validation.
2724   --------------------------------------------------------------------------*/
2725
2726 /*---------------------------------------------------------------------------
2727 |   Facility      :  libnform  
2728 |   Function      :  static int FV_Validation(FORM * form)
2729 |   
2730 |   Description   :  Validate the current field of the form.
2731 |
2732 |   Return Values :  E_OK             - field valid
2733 |                    E_INVALID_FIELD  - field not valid
2734 +--------------------------------------------------------------------------*/
2735 static int FV_Validation(FORM * form)
2736 {
2737   if (_nc_Internal_Validation(form))
2738     return E_OK;
2739   else
2740     return E_INVALID_FIELD;
2741 }
2742 /*----------------------------------------------------------------------------
2743   End of routines for Field Validation.
2744   --------------------------------------------------------------------------*/
2745 \f
2746 /*----------------------------------------------------------------------------
2747   Helper routines for Inter-Field Navigation
2748   --------------------------------------------------------------------------*/
2749
2750 /*---------------------------------------------------------------------------
2751 |   Facility      :  libnform  
2752 |   Function      :  static FIELD *Next_Field_On_Page(FIELD * field)
2753 |   
2754 |   Description   :  Get the next field after the given field on the current 
2755 |                    page. The order of fields is the one defined by the
2756 |                    fields array. Only visible and active fields are
2757 |                    counted.
2758 |
2759 |   Return Values :  Pointer to the next field.
2760 +--------------------------------------------------------------------------*/
2761 INLINE static FIELD *Next_Field_On_Page(FIELD * field)
2762 {
2763   FORM  *form = field->form;
2764   FIELD **field_on_page = &form->field[field->index];
2765   FIELD **first_on_page = &form->field[form->page[form->curpage].pmin];
2766   FIELD **last_on_page  = &form->field[form->page[form->curpage].pmax];
2767
2768   do
2769     {
2770       field_on_page = 
2771         (field_on_page==last_on_page) ? first_on_page : field_on_page + 1;
2772       if (Field_Is_Selectable(*field_on_page))
2773         break;
2774     } while(field!=(*field_on_page));  
2775   return(*field_on_page);
2776 }
2777
2778 /*---------------------------------------------------------------------------
2779 |   Facility      :  libnform  
2780 |   Function      :  FIELD* _nc_First_Active_Field(FORM * form)
2781 |   
2782 |   Description   :  Get the first active field on the current page,
2783 |                    if there are such. If there are none, get the first
2784 |                    visible field on the page. If there are also none,
2785 |                    we return the first field on page and hope the best.
2786 |
2787 |   Return Values :  Pointer to calculated field.
2788 +--------------------------------------------------------------------------*/
2789 NCURSES_EXPORT(FIELD*)
2790 _nc_First_Active_Field (FORM * form)
2791 {
2792   FIELD **last_on_page = &form->field[form->page[form->curpage].pmax];
2793   FIELD *proposed = Next_Field_On_Page(*last_on_page);
2794
2795   if (proposed == *last_on_page)
2796     { /* there might be the special situation, where there is no 
2797          active and visible field on the current page. We then select
2798          the first visible field on this readonly page
2799       */
2800       if (Field_Is_Not_Selectable(proposed))
2801         {
2802           FIELD **field = &form->field[proposed->index];
2803           FIELD **first = &form->field[form->page[form->curpage].pmin];
2804
2805           do
2806             {
2807               field = (field==last_on_page) ? first : field + 1;
2808               if (((*field)->opts & O_VISIBLE))
2809                 break;
2810             } while(proposed!=(*field));
2811           
2812           proposed = *field;
2813
2814           if ((proposed == *last_on_page) && !(proposed->opts&O_VISIBLE))
2815             { /* This means, there is also no visible field on the page.
2816                  So we propose the first one and hope the very best... 
2817                  Some very clever user has designed a readonly and invisible
2818                  page on this form.
2819                */
2820               proposed = *first;
2821             }
2822         }
2823     }
2824   return(proposed);
2825 }
2826
2827 /*---------------------------------------------------------------------------
2828 |   Facility      :  libnform  
2829 |   Function      :  static FIELD *Previous_Field_On_Page(FIELD * field)
2830 |   
2831 |   Description   :  Get the previous field before the given field on the 
2832 |                    current page. The order of fields is the one defined by 
2833 |                    the fields array. Only visible and active fields are
2834 |                    counted.
2835 |
2836 |   Return Values :  Pointer to the previous field.
2837 +--------------------------------------------------------------------------*/
2838 INLINE static FIELD *Previous_Field_On_Page(FIELD * field)
2839 {
2840   FORM  *form   = field->form;
2841   FIELD **field_on_page = &form->field[field->index];
2842   FIELD **first_on_page = &form->field[form->page[form->curpage].pmin];
2843   FIELD **last_on_page  = &form->field[form->page[form->curpage].pmax];
2844   
2845   do
2846     {
2847       field_on_page = 
2848         (field_on_page==first_on_page) ? last_on_page : field_on_page - 1;
2849       if (Field_Is_Selectable(*field_on_page))
2850         break;
2851     } while(field!=(*field_on_page));
2852   
2853   return (*field_on_page);
2854 }
2855
2856 /*---------------------------------------------------------------------------
2857 |   Facility      :  libnform  
2858 |   Function      :  static FIELD *Sorted_Next_Field(FIELD * field)
2859 |   
2860 |   Description   :  Get the next field after the given field on the current 
2861 |                    page. The order of fields is the one defined by the
2862 |                    (row,column) geometry, rows are major.
2863 |
2864 |   Return Values :  Pointer to the next field.
2865 +--------------------------------------------------------------------------*/
2866 INLINE static FIELD *Sorted_Next_Field(FIELD * field)
2867 {
2868   FIELD *field_on_page = field;
2869
2870   do
2871     {
2872       field_on_page = field_on_page->snext;
2873       if (Field_Is_Selectable(field_on_page))
2874         break;
2875     } while(field_on_page!=field);
2876   
2877   return (field_on_page);
2878 }
2879
2880 /*---------------------------------------------------------------------------
2881 |   Facility      :  libnform  
2882 |   Function      :  static FIELD *Sorted_Previous_Field(FIELD * field)
2883 |   
2884 |   Description   :  Get the previous field before the given field on the 
2885 |                    current page. The order of fields is the one defined 
2886 |                    by the (row,column) geometry, rows are major.
2887 |
2888 |   Return Values :  Pointer to the previous field.
2889 +--------------------------------------------------------------------------*/
2890 INLINE static FIELD *Sorted_Previous_Field(FIELD * field)
2891 {
2892   FIELD *field_on_page = field;
2893
2894   do
2895     {
2896       field_on_page = field_on_page->sprev;
2897       if (Field_Is_Selectable(field_on_page))
2898         break;
2899     } while(field_on_page!=field);
2900   
2901   return (field_on_page);
2902 }
2903
2904 /*---------------------------------------------------------------------------
2905 |   Facility      :  libnform  
2906 |   Function      :  static FIELD *Left_Neighbour_Field(FIELD * field)
2907 |   
2908 |   Description   :  Get the left neighbour of the field on the same line
2909 |                    and the same page. Cycles through the line.
2910 |
2911 |   Return Values :  Pointer to left neighbour field.
2912 +--------------------------------------------------------------------------*/
2913 INLINE static FIELD *Left_Neighbour_Field(FIELD * field)
2914 {
2915   FIELD *field_on_page = field;
2916
2917   /* For a field that has really a left neighbour, the while clause
2918      immediately fails and the loop is left, positioned at the right
2919      neighbour. Otherwise we cycle backwards through the sorted fieldlist
2920      until we enter the same line (from the right end).
2921   */
2922   do
2923     {
2924       field_on_page = Sorted_Previous_Field(field_on_page);
2925     } while(field_on_page->frow != field->frow);
2926   
2927   return (field_on_page);
2928 }
2929
2930 /*---------------------------------------------------------------------------
2931 |   Facility      :  libnform  
2932 |   Function      :  static FIELD *Right_Neighbour_Field(FIELD * field)
2933 |   
2934 |   Description   :  Get the right neighbour of the field on the same line
2935 |                    and the same page.
2936 |
2937 |   Return Values :  Pointer to right neighbour field.
2938 +--------------------------------------------------------------------------*/
2939 INLINE static FIELD *Right_Neighbour_Field(FIELD * field)
2940 {
2941   FIELD *field_on_page = field;
2942
2943   /* See the comments on Left_Neighbour_Field to understand how it works */
2944   do
2945     {
2946       field_on_page = Sorted_Next_Field(field_on_page);
2947     } while(field_on_page->frow != field->frow);
2948   
2949   return (field_on_page);
2950 }
2951
2952 /*---------------------------------------------------------------------------
2953 |   Facility      :  libnform  
2954 |   Function      :  static FIELD *Upper_Neighbour_Field(FIELD * field)
2955 |   
2956 |   Description   :  Because of the row-major nature of sorting the fields,
2957 |                    its more difficult to define whats the upper neighbour
2958 |                    field really means. We define that it must be on a
2959 |                    'previous' line (cyclic order!) and is the rightmost
2960 |                    field laying on the left side of the given field. If
2961 |                    this set is empty, we take the first field on the line.
2962 |
2963 |   Return Values :  Pointer to the upper neighbour field.
2964 +--------------------------------------------------------------------------*/
2965 static FIELD *Upper_Neighbour_Field(FIELD * field)
2966 {
2967   FIELD *field_on_page = field;
2968   int frow = field->frow;
2969   int fcol = field->fcol;
2970
2971   /* Walk back to the 'previous' line. The second term in the while clause
2972      just guarantees that we stop if we cycled through the line because
2973      there might be no 'previous' line if the page has just one line.
2974   */
2975   do
2976     {
2977       field_on_page = Sorted_Previous_Field(field_on_page);
2978     } while(field_on_page->frow==frow && field_on_page->fcol!=fcol);
2979   
2980   if (field_on_page->frow!=frow)
2981     { /* We really found a 'previous' line. We are positioned at the
2982          rightmost field on this line */
2983       frow = field_on_page->frow; 
2984
2985       /* We walk to the left as long as we are really right of the 
2986          field. */
2987       while(field_on_page->frow==frow && field_on_page->fcol>fcol)
2988         field_on_page = Sorted_Previous_Field(field_on_page);
2989
2990       /* If we wrapped, just go to the right which is the first field on 
2991          the row */
2992       if (field_on_page->frow!=frow)
2993         field_on_page = Sorted_Next_Field(field_on_page);
2994     }
2995   
2996   return (field_on_page);
2997 }
2998
2999 /*---------------------------------------------------------------------------
3000 |   Facility      :  libnform  
3001 |   Function      :  static FIELD *Down_Neighbour_Field(FIELD * field)
3002 |   
3003 |   Description   :  Because of the row-major nature of sorting the fields,
3004 |                    its more difficult to define whats the down neighbour
3005 |                    field really means. We define that it must be on a
3006 |                    'next' line (cyclic order!) and is the leftmost
3007 |                    field laying on the right side of the given field. If
3008 |                    this set is empty, we take the last field on the line.
3009 |
3010 |   Return Values :  Pointer to the upper neighbour field.
3011 +--------------------------------------------------------------------------*/
3012 static FIELD *Down_Neighbour_Field(FIELD * field)
3013 {
3014   FIELD *field_on_page = field;
3015   int frow = field->frow;
3016   int fcol = field->fcol;
3017
3018   /* Walk forward to the 'next' line. The second term in the while clause
3019      just guarantees that we stop if we cycled through the line because
3020      there might be no 'next' line if the page has just one line.
3021   */
3022   do
3023     {
3024       field_on_page = Sorted_Next_Field(field_on_page);
3025     } while(field_on_page->frow==frow && field_on_page->fcol!=fcol);
3026
3027   if (field_on_page->frow!=frow)
3028     { /* We really found a 'next' line. We are positioned at the rightmost
3029          field on this line */
3030       frow = field_on_page->frow;
3031
3032       /* We walk to the right as long as we are really left of the 
3033          field. */
3034       while(field_on_page->frow==frow && field_on_page->fcol<fcol)
3035         field_on_page = Sorted_Next_Field(field_on_page);
3036
3037       /* If we wrapped, just go to the left which is the last field on 
3038          the row */
3039       if (field_on_page->frow!=frow)
3040         field_on_page = Sorted_Previous_Field(field_on_page);
3041     }
3042   
3043   return(field_on_page);
3044 }
3045 \f
3046 /*----------------------------------------------------------------------------
3047   Inter-Field Navigation routines
3048   --------------------------------------------------------------------------*/
3049
3050 /*---------------------------------------------------------------------------
3051 |   Facility      :  libnform  
3052 |   Function      :  static int Inter_Field_Navigation(
3053 |                                           int (* const fct) (FORM *),
3054 |                                           FORM * form)
3055 |   
3056 |   Description   :  Generic behaviour for changing the current field, the
3057 |                    field is left and a new field is entered. So the field
3058 |                    must be validated and the field init/term hooks must
3059 |                    be called.
3060 |
3061 |   Return Values :  E_OK                - success
3062 |                    E_INVALID_FIELD     - field is invalid
3063 |                    some other          - error from subordinate call
3064 +--------------------------------------------------------------------------*/
3065 static int Inter_Field_Navigation(int (* const fct) (FORM *),FORM *form)
3066 {
3067   int res;
3068
3069   if (!_nc_Internal_Validation(form)) 
3070     res = E_INVALID_FIELD;
3071   else
3072     {
3073       Call_Hook(form,fieldterm);
3074       res = fct(form);
3075       Call_Hook(form,fieldinit);
3076     }
3077   return res;
3078 }
3079
3080 /*---------------------------------------------------------------------------
3081 |   Facility      :  libnform  
3082 |   Function      :  static int FN_Next_Field(FORM * form)
3083 |   
3084 |   Description   :  Move to the next field on the current page of the form
3085 |
3086 |   Return Values :  E_OK                 - success
3087 |                    != E_OK              - error from subordinate call
3088 +--------------------------------------------------------------------------*/
3089 static int FN_Next_Field(FORM * form)
3090 {
3091   return _nc_Set_Current_Field(form,
3092                                Next_Field_On_Page(form->current));
3093 }
3094
3095 /*---------------------------------------------------------------------------
3096 |   Facility      :  libnform  
3097 |   Function      :  static int FN_Previous_Field(FORM * form)
3098 |   
3099 |   Description   :  Move to the previous field on the current page of the 
3100 |                    form
3101 |
3102 |   Return Values :  E_OK                 - success
3103 |                    != E_OK              - error from subordinate call
3104 +--------------------------------------------------------------------------*/
3105 static int FN_Previous_Field(FORM * form)
3106 {
3107   return _nc_Set_Current_Field(form,
3108                                Previous_Field_On_Page(form->current));
3109 }
3110
3111 /*---------------------------------------------------------------------------
3112 |   Facility      :  libnform  
3113 |   Function      :  static int FN_First_Field(FORM * form)
3114 |   
3115 |   Description   :  Move to the first field on the current page of the form
3116 |
3117 |   Return Values :  E_OK                 - success
3118 |                    != E_OK              - error from subordinate call
3119 +--------------------------------------------------------------------------*/
3120 static int FN_First_Field(FORM * form)
3121 {
3122   return _nc_Set_Current_Field(form,
3123       Next_Field_On_Page(form->field[form->page[form->curpage].pmax]));
3124 }
3125
3126 /*---------------------------------------------------------------------------
3127 |   Facility      :  libnform  
3128 |   Function      :  static int FN_Last_Field(FORM * form)
3129 |   
3130 |   Description   :  Move to the last field on the current page of the form
3131 |
3132 |   Return Values :  E_OK                 - success
3133 |                    != E_OK              - error from subordinate call
3134 +--------------------------------------------------------------------------*/
3135 static int FN_Last_Field(FORM * form)
3136 {
3137   return 
3138     _nc_Set_Current_Field(form,
3139        Previous_Field_On_Page(form->field[form->page[form->curpage].pmin]));
3140 }
3141
3142 /*---------------------------------------------------------------------------
3143 |   Facility      :  libnform  
3144 |   Function      :  static int FN_Sorted_Next_Field(FORM * form)
3145 |   
3146 |   Description   :  Move to the sorted next field on the current page
3147 |                    of the form.
3148 |
3149 |   Return Values :  E_OK            - success
3150 |                    != E_OK         - error from subordinate call
3151 +--------------------------------------------------------------------------*/
3152 static int FN_Sorted_Next_Field(FORM * form)
3153 {
3154   return _nc_Set_Current_Field(form,
3155                                Sorted_Next_Field(form->current));
3156 }
3157
3158 /*---------------------------------------------------------------------------
3159 |   Facility      :  libnform  
3160 |   Function      :  static int FN_Sorted_Previous_Field(FORM * form)
3161 |   
3162 |   Description   :  Move to the sorted previous field on the current page
3163 |                    of the form.
3164 |
3165 |   Return Values :  E_OK            - success
3166 |                    != E_OK         - error from subordinate call
3167 +--------------------------------------------------------------------------*/
3168 static int FN_Sorted_Previous_Field(FORM * form)
3169 {
3170   return _nc_Set_Current_Field(form,
3171                                Sorted_Previous_Field(form->current));
3172 }
3173
3174 /*---------------------------------------------------------------------------
3175 |   Facility      :  libnform  
3176 |   Function      :  static int FN_Sorted_First_Field(FORM * form)
3177 |   
3178 |   Description   :  Move to the sorted first field on the current page
3179 |                    of the form.
3180 |
3181 |   Return Values :  E_OK            - success
3182 |                    != E_OK         - error from subordinate call
3183 +--------------------------------------------------------------------------*/
3184 static int FN_Sorted_First_Field(FORM * form)
3185 {
3186   return _nc_Set_Current_Field(form,
3187               Sorted_Next_Field(form->field[form->page[form->curpage].smax]));
3188 }
3189
3190 /*---------------------------------------------------------------------------
3191 |   Facility      :  libnform  
3192 |   Function      :  static int FN_Sorted_Last_Field(FORM * form)
3193 |   
3194 |   Description   :  Move to the sorted last field on the current page
3195 |                    of the form.
3196 |
3197 |   Return Values :  E_OK            - success
3198 |                    != E_OK         - error from subordinate call
3199 +--------------------------------------------------------------------------*/
3200 static int FN_Sorted_Last_Field(FORM * form)
3201 {
3202   return _nc_Set_Current_Field(form,
3203            Sorted_Previous_Field(form->field[form->page[form->curpage].smin]));
3204 }
3205
3206 /*---------------------------------------------------------------------------
3207 |   Facility      :  libnform  
3208 |   Function      :  static int FN_Left_Field(FORM * form)
3209 |   
3210 |   Description   :  Get the field on the left of the current field on the
3211 |                    same line and the same page. Cycles through the line.
3212 |
3213 |   Return Values :  E_OK            - success
3214 |                    != E_OK         - error from subordinate call
3215 +--------------------------------------------------------------------------*/
3216 static int FN_Left_Field(FORM * form)
3217 {
3218   return _nc_Set_Current_Field(form,
3219                                Left_Neighbour_Field(form->current));
3220 }
3221
3222 /*---------------------------------------------------------------------------
3223 |   Facility      :  libnform  
3224 |   Function      :  static int FN_Right_Field(FORM * form)
3225 |   
3226 |   Description   :  Get the field on the right of the current field on the
3227 |                    same line and the same page. Cycles through the line.
3228 |
3229 |   Return Values :  E_OK            - success
3230 |                    != E_OK         - error from subordinate call
3231 +--------------------------------------------------------------------------*/
3232 static int FN_Right_Field(FORM * form)
3233 {
3234   return _nc_Set_Current_Field(form,
3235                                Right_Neighbour_Field(form->current));
3236 }
3237
3238 /*---------------------------------------------------------------------------
3239 |   Facility      :  libnform  
3240 |   Function      :  static int FN_Up_Field(FORM * form)
3241 |   
3242 |   Description   :  Get the upper neighbour of the current field. This
3243 |                    cycles through the page. See the comments of the
3244 |                    Upper_Neighbour_Field function to understand how
3245 |                    'upper' is defined. 
3246 |
3247 |   Return Values :  E_OK            - success
3248 |                    != E_OK         - error from subordinate call
3249 +--------------------------------------------------------------------------*/
3250 static int FN_Up_Field(FORM * form)
3251 {
3252   return _nc_Set_Current_Field(form,
3253                                Upper_Neighbour_Field(form->current));
3254 }
3255
3256 /*---------------------------------------------------------------------------
3257 |   Facility      :  libnform  
3258 |   Function      :  static int FN_Down_Field(FORM * form)
3259 |   
3260 |   Description   :  Get the down neighbour of the current field. This
3261 |                    cycles through the page. See the comments of the
3262 |                    Down_Neighbour_Field function to understand how
3263 |                    'down' is defined. 
3264 |
3265 |   Return Values :  E_OK            - success
3266 |                    != E_OK         - error from subordinate call
3267 +--------------------------------------------------------------------------*/
3268 static int FN_Down_Field(FORM * form)
3269 {
3270   return _nc_Set_Current_Field(form,
3271                                Down_Neighbour_Field(form->current));
3272 }
3273 /*----------------------------------------------------------------------------
3274   END of Field Navigation routines 
3275   --------------------------------------------------------------------------*/
3276 \f
3277 /*----------------------------------------------------------------------------
3278   Helper routines for Page Navigation
3279   --------------------------------------------------------------------------*/
3280
3281 /*---------------------------------------------------------------------------
3282 |   Facility      :  libnform  
3283 |   Function      :  int _nc_Set_Form_Page(FORM * form,
3284 |                                          int page,
3285 |                                          FIELD * field)
3286 |   
3287 |   Description   :  Make the given page nr. the current page and make
3288 |                    the given field the current field on the page. If
3289 |                    for the field NULL is given, make the first field on
3290 |                    the page the current field. The routine acts only
3291 |                    if the requested page is not the current page.
3292 |
3293 |   Return Values :  E_OK                - success
3294 |                    != E_OK             - error from subordinate call
3295 +--------------------------------------------------------------------------*/
3296 NCURSES_EXPORT(int)
3297 _nc_Set_Form_Page
3298 (FORM * form, int page, FIELD * field)
3299 {
3300   int res = E_OK;
3301
3302   if ((form->curpage!=page))
3303     {
3304       FIELD *last_field, *field_on_page;
3305
3306       werase(Get_Form_Window(form));
3307       form->curpage = page;
3308       last_field = field_on_page = form->field[form->page[page].smin];
3309       do
3310         {
3311           if (field_on_page->opts & O_VISIBLE)
3312             if ((res=Display_Field(field_on_page))!=E_OK) 
3313               return(res);
3314           field_on_page = field_on_page->snext;
3315         } while(field_on_page != last_field);
3316
3317       if (field)
3318         res = _nc_Set_Current_Field(form,field);
3319       else
3320         /* N.B.: we don't encapsulate this by Inter_Field_Navigation(),
3321            because this is already executed in a page navigation
3322            context that contains field navigation 
3323          */
3324         res = FN_First_Field(form);
3325     }
3326   return(res);
3327 }
3328
3329 /*---------------------------------------------------------------------------
3330 |   Facility      :  libnform  
3331 |   Function      :  static int Next_Page_Number(const FORM * form)
3332 |   
3333 |   Description   :  Calculate the page number following the current page
3334 |                    number. This cycles if the highest page number is
3335 |                    reached.  
3336 |
3337 |   Return Values :  The next page number
3338 +--------------------------------------------------------------------------*/
3339 INLINE static int Next_Page_Number(const FORM * form)
3340 {
3341   return (form->curpage + 1) % form->maxpage;
3342 }
3343
3344 /*---------------------------------------------------------------------------
3345 |   Facility      :  libnform  
3346 |   Function      :  static int Previous_Page_Number(const FORM * form)
3347 |   
3348 |   Description   :  Calculate the page number before the current page
3349 |                    number. This cycles if the first page number is
3350 |                    reached.  
3351 |
3352 |   Return Values :  The previous page number
3353 +--------------------------------------------------------------------------*/
3354 INLINE static int Previous_Page_Number(const FORM * form)
3355 {
3356   return (form->curpage!=0 ? form->curpage - 1 : form->maxpage - 1);
3357 }
3358 \f
3359 /*----------------------------------------------------------------------------
3360   Page Navigation routines 
3361   --------------------------------------------------------------------------*/
3362
3363 /*---------------------------------------------------------------------------
3364 |   Facility      :  libnform  
3365 |   Function      :  static int Page_Navigation(
3366 |                                               int (* const fct) (FORM *),
3367 |                                               FORM * form)
3368 |   
3369 |   Description   :  Generic behaviour for changing a page. This means
3370 |                    that the field is left and a new field is entered.
3371 |                    So the field must be validated and the field init/term
3372 |                    hooks must be called. Because also the page is changed,
3373 |                    the forms init/term hooks must be called also.
3374 |
3375 |   Return Values :  E_OK                - success
3376 |                    E_INVALID_FIELD     - field is invalid
3377 |                    some other          - error from subordinate call
3378 +--------------------------------------------------------------------------*/
3379 static int Page_Navigation(int (* const fct) (FORM *), FORM * form)
3380 {
3381   int res;
3382
3383   if (!_nc_Internal_Validation(form)) 
3384     res = E_INVALID_FIELD;
3385   else
3386     {
3387       Call_Hook(form,fieldterm);
3388       Call_Hook(form,formterm);
3389       res = fct(form);
3390       Call_Hook(form,forminit);
3391       Call_Hook(form,fieldinit);
3392     }
3393   return res;
3394 }
3395
3396 /*---------------------------------------------------------------------------
3397 |   Facility      :  libnform  
3398 |   Function      :  static int PN_Next_Page(FORM * form)
3399 |   
3400 |   Description   :  Move to the next page of the form
3401 |
3402 |   Return Values :  E_OK                - success
3403 |                    != E_OK             - error from subordinate call
3404 +--------------------------------------------------------------------------*/
3405 static int PN_Next_Page(FORM * form)
3406
3407   return _nc_Set_Form_Page(form,Next_Page_Number(form),(FIELD *)0);
3408 }
3409
3410 /*---------------------------------------------------------------------------
3411 |   Facility      :  libnform  
3412 |   Function      :  static int PN_Previous_Page(FORM * form)
3413 |   
3414 |   Description   :  Move to the previous page of the form
3415 |
3416 |   Return Values :  E_OK              - success
3417 |                    != E_OK           - error from subordinate call
3418 +--------------------------------------------------------------------------*/
3419 static int PN_Previous_Page(FORM * form)
3420 {
3421   return _nc_Set_Form_Page(form,Previous_Page_Number(form),(FIELD *)0);
3422 }
3423
3424 /*---------------------------------------------------------------------------
3425 |   Facility      :  libnform  
3426 |   Function      :  static int PN_First_Page(FORM * form)
3427 |   
3428 |   Description   :  Move to the first page of the form
3429 |
3430 |   Return Values :  E_OK              - success
3431 |                    != E_OK           - error from subordinate call
3432 +--------------------------------------------------------------------------*/
3433 static int PN_First_Page(FORM * form)
3434 {
3435   return _nc_Set_Form_Page(form,0,(FIELD *)0);
3436 }
3437
3438 /*---------------------------------------------------------------------------
3439 |   Facility      :  libnform  
3440 |   Function      :  static int PN_Last_Page(FORM * form)
3441 |   
3442 |   Description   :  Move to the last page of the form
3443 |
3444 |   Return Values :  E_OK              - success
3445 |                    != E_OK           - error from subordinate call
3446 +--------------------------------------------------------------------------*/
3447 static int PN_Last_Page(FORM * form)
3448 {
3449   return _nc_Set_Form_Page(form,form->maxpage-1,(FIELD *)0);
3450 }
3451 /*----------------------------------------------------------------------------
3452   END of Field Navigation routines 
3453   --------------------------------------------------------------------------*/
3454 \f
3455 /*----------------------------------------------------------------------------
3456   Helper routines for the core form driver.
3457   --------------------------------------------------------------------------*/
3458
3459 /*---------------------------------------------------------------------------
3460 |   Facility      :  libnform  
3461 |   Function      :  static int Data_Entry(FORM * form,int c)
3462 |   
3463 |   Description   :  Enter character c into at the current position of the
3464 |                    current field of the form.
3465 |
3466 |   Return Values :  E_OK              -
3467 |                    E_REQUEST_DENIED  -
3468 |                    E_SYSTEM_ERROR    -
3469 +--------------------------------------------------------------------------*/
3470 static int Data_Entry(FORM * form, int c)
3471 {
3472   FIELD  *field = form->current;
3473   int result = E_REQUEST_DENIED;
3474
3475   if ( (field->opts & O_EDIT) 
3476 #if FIX_FORM_INACTIVE_BUG
3477        && (field->opts & O_ACTIVE) 
3478 #endif
3479        )
3480     {
3481       if ( (field->opts & O_BLANK) &&
3482            First_Position_In_Current_Field(form) &&
3483            !(form->status & _FCHECK_REQUIRED) && 
3484            !(form->status & _WINDOW_MODIFIED) )
3485         werase(form->w);
3486
3487       if (form->status & _OVLMODE)
3488         {
3489           waddch(form->w,(chtype)c);
3490         } 
3491       else /* no _OVLMODE */ 
3492         {
3493           bool There_Is_Room = Is_There_Room_For_A_Char_In_Line(form);
3494
3495           if (!(There_Is_Room ||
3496                 ((Single_Line_Field(field) && Growable(field)))))
3497               return E_REQUEST_DENIED;
3498
3499           if (!There_Is_Room && !Field_Grown(field,1))
3500             return E_SYSTEM_ERROR;
3501
3502           winsch(form->w,(chtype)c);
3503         }
3504
3505       if ((result=Wrapping_Not_Necessary_Or_Wrapping_Ok(form))==E_OK)
3506         {
3507           bool End_Of_Field= (((field->drows-1)==form->currow) &&
3508                               ((field->dcols-1)==form->curcol));
3509           form->status |= _WINDOW_MODIFIED;
3510           if (End_Of_Field && !Growable(field) && (field->opts & O_AUTOSKIP))
3511             result = Inter_Field_Navigation(FN_Next_Field,form);
3512           else
3513             {
3514               if (End_Of_Field && Growable(field) && !Field_Grown(field,1))
3515                 result = E_SYSTEM_ERROR;
3516               else
3517                 {
3518                   IFN_Next_Character(form);
3519                   result = E_OK;
3520                 }
3521             }
3522         }
3523     }
3524   return result;
3525 }
3526 \f
3527 /* Structure to describe the binding of a request code to a function.
3528    The member keycode codes the request value as well as the generic
3529    routine to use for the request. The code for the generic routine
3530    is coded in the upper 16 Bits while the request code is coded in
3531    the lower 16 bits. 
3532
3533    In terms of C++ you might think of a request as a class with a
3534    virtual method "perform". The different types of request are
3535    derived from this base class and overload (or not) the base class
3536    implementation of perform.
3537 */
3538 typedef struct {
3539   int keycode;           /* must be at least 32 bit: hi:mode, lo: key */
3540   int (*cmd)(FORM *);    /* low level driver routine for this key     */
3541 } Binding_Info;
3542
3543 /* You may see this is the class-id of the request type class */
3544 #define ID_PN    (0x00000000)    /* Page navigation           */
3545 #define ID_FN    (0x00010000)    /* Inter-Field navigation    */
3546 #define ID_IFN   (0x00020000)    /* Intra-Field navigation    */
3547 #define ID_VSC   (0x00030000)    /* Vertical Scrolling        */
3548 #define ID_HSC   (0x00040000)    /* Horizontal Scrolling      */
3549 #define ID_FE    (0x00050000)    /* Field Editing             */
3550 #define ID_EM    (0x00060000)    /* Edit Mode                 */
3551 #define ID_FV    (0x00070000)    /* Field Validation          */
3552 #define ID_CH    (0x00080000)    /* Choice                    */
3553 #define ID_Mask  (0xffff0000)
3554 #define Key_Mask (0x0000ffff)
3555 #define ID_Shft  (16)
3556
3557 /* This array holds all the Binding Infos */
3558 static const Binding_Info bindings[MAX_FORM_COMMAND - MIN_FORM_COMMAND + 1] = 
3559 {
3560   { REQ_NEXT_PAGE    |ID_PN  ,PN_Next_Page},
3561   { REQ_PREV_PAGE    |ID_PN  ,PN_Previous_Page},
3562   { REQ_FIRST_PAGE   |ID_PN  ,PN_First_Page},
3563   { REQ_LAST_PAGE    |ID_PN  ,PN_Last_Page},
3564   
3565   { REQ_NEXT_FIELD   |ID_FN  ,FN_Next_Field},
3566   { REQ_PREV_FIELD   |ID_FN  ,FN_Previous_Field},
3567   { REQ_FIRST_FIELD  |ID_FN  ,FN_First_Field},
3568   { REQ_LAST_FIELD   |ID_FN  ,FN_Last_Field},
3569   { REQ_SNEXT_FIELD  |ID_FN  ,FN_Sorted_Next_Field},
3570   { REQ_SPREV_FIELD  |ID_FN  ,FN_Sorted_Previous_Field},
3571   { REQ_SFIRST_FIELD |ID_FN  ,FN_Sorted_First_Field},
3572   { REQ_SLAST_FIELD  |ID_FN  ,FN_Sorted_Last_Field},
3573   { REQ_LEFT_FIELD   |ID_FN  ,FN_Left_Field},
3574   { REQ_RIGHT_FIELD  |ID_FN  ,FN_Right_Field},
3575   { REQ_UP_FIELD     |ID_FN  ,FN_Up_Field},
3576   { REQ_DOWN_FIELD   |ID_FN  ,FN_Down_Field},
3577   
3578   { REQ_NEXT_CHAR    |ID_IFN ,IFN_Next_Character},
3579   { REQ_PREV_CHAR    |ID_IFN ,IFN_Previous_Character},
3580   { REQ_NEXT_LINE    |ID_IFN ,IFN_Next_Line},
3581   { REQ_PREV_LINE    |ID_IFN ,IFN_Previous_Line},
3582   { REQ_NEXT_WORD    |ID_IFN ,IFN_Next_Word},
3583   { REQ_PREV_WORD    |ID_IFN ,IFN_Previous_Word},
3584   { REQ_BEG_FIELD    |ID_IFN ,IFN_Beginning_Of_Field},
3585   { REQ_END_FIELD    |ID_IFN ,IFN_End_Of_Field},
3586   { REQ_BEG_LINE     |ID_IFN ,IFN_Beginning_Of_Line},
3587   { REQ_END_LINE     |ID_IFN ,IFN_End_Of_Line},
3588   { REQ_LEFT_CHAR    |ID_IFN ,IFN_Left_Character},
3589   { REQ_RIGHT_CHAR   |ID_IFN ,IFN_Right_Character},
3590   { REQ_UP_CHAR      |ID_IFN ,IFN_Up_Character},
3591   { REQ_DOWN_CHAR    |ID_IFN ,IFN_Down_Character},
3592   
3593   { REQ_NEW_LINE     |ID_FE  ,FE_New_Line},
3594   { REQ_INS_CHAR     |ID_FE  ,FE_Insert_Character},
3595   { REQ_INS_LINE     |ID_FE  ,FE_Insert_Line},
3596   { REQ_DEL_CHAR     |ID_FE  ,FE_Delete_Character},
3597   { REQ_DEL_PREV     |ID_FE  ,FE_Delete_Previous},
3598   { REQ_DEL_LINE     |ID_FE  ,FE_Delete_Line},
3599   { REQ_DEL_WORD     |ID_FE  ,FE_Delete_Word},
3600   { REQ_CLR_EOL      |ID_FE  ,FE_Clear_To_End_Of_Line},
3601   { REQ_CLR_EOF      |ID_FE  ,FE_Clear_To_End_Of_Form},
3602   { REQ_CLR_FIELD    |ID_FE  ,FE_Clear_Field},
3603   
3604   { REQ_OVL_MODE     |ID_EM  ,EM_Overlay_Mode},
3605   { REQ_INS_MODE     |ID_EM  ,EM_Insert_Mode},
3606   
3607   { REQ_SCR_FLINE    |ID_VSC ,VSC_Scroll_Line_Forward},
3608   { REQ_SCR_BLINE    |ID_VSC ,VSC_Scroll_Line_Backward},
3609   { REQ_SCR_FPAGE    |ID_VSC ,VSC_Scroll_Page_Forward},
3610   { REQ_SCR_BPAGE    |ID_VSC ,VSC_Scroll_Page_Backward},
3611   { REQ_SCR_FHPAGE   |ID_VSC ,VSC_Scroll_Half_Page_Forward},
3612   { REQ_SCR_BHPAGE   |ID_VSC ,VSC_Scroll_Half_Page_Backward},
3613   
3614   { REQ_SCR_FCHAR    |ID_HSC ,HSC_Scroll_Char_Forward},
3615   { REQ_SCR_BCHAR    |ID_HSC ,HSC_Scroll_Char_Backward},
3616   { REQ_SCR_HFLINE   |ID_HSC ,HSC_Horizontal_Line_Forward},
3617   { REQ_SCR_HBLINE   |ID_HSC ,HSC_Horizontal_Line_Backward},
3618   { REQ_SCR_HFHALF   |ID_HSC ,HSC_Horizontal_Half_Line_Forward},
3619   { REQ_SCR_HBHALF   |ID_HSC ,HSC_Horizontal_Half_Line_Backward},
3620   
3621   { REQ_VALIDATION   |ID_FV  ,FV_Validation},
3622
3623   { REQ_NEXT_CHOICE  |ID_CH  ,CR_Next_Choice},
3624   { REQ_PREV_CHOICE  |ID_CH  ,CR_Previous_Choice}
3625 };
3626
3627 /*---------------------------------------------------------------------------
3628 |   Facility      :  libnform  
3629 |   Function      :  int form_driver(FORM * form,int  c)
3630 |   
3631 |   Description   :  This is the workhorse of the forms system. It checks
3632 |                    to determine whether the character c is a request or
3633 |                    data. If it is a request, the form driver executes
3634 |                    the request and returns the result. If it is data
3635 |                    (printable character), it enters the data into the
3636 |                    current position in the current field. If it is not