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 Essentially 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 Essentially 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/*
81Some options that may effect compatibility in behavior to SVr4 forms,
82but they are here to allow a more intuitive and user friendly behavior of
83our form implementation. This doesn't affect the API, so we feel it is
84uncritical.
85
86The initial implementation tries to stay very close with the behavior
87of the original SVr4 implementation, although in some areas it is quite
88clear that this isn't the most appropriate way. As far as possible this
89sources will allow you to build a forms lib that behaves quite similar
90to SVr4, but now and in the future we will give you better options.
91Perhaps at some time we will make this configurable at runtime.
92*/
93
94/* Implement a more user-friendly previous/next word behavior */
95#define FRIENDLY_PREV_NEXT_WORD (1)
96/* Fix the wrong behavior 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#if USE_WIDEC_SUPPORT
102#define myADDNSTR(w, s, n) wadd_wchnstr(w, s, n)
103#define myINSNSTR(w, s, n) wins_wchnstr(w, s, n)
104#define myINNSTR(w, s, n) fix_wchnstr(w, s, n)
105#define myWCWIDTH(w, y, x) cell_width(w, y, x)
106#else
107#define myADDNSTR(w, s, n) waddnstr(w, s, n)
108#define myINSNSTR(w, s, n) winsnstr(w, s, n)
109#define myINNSTR(w, s, n) winnstr(w, s, n)
110#define myWCWIDTH(w, y, x) 1
111#endif
112
113/*----------------------------------------------------------------------------
114 Forward references to some internally used static functions
115 --------------------------------------------------------------------------*/
116static int Inter_Field_Navigation(int (*const fct) (FORM *), FORM *form);
117static int FN_Next_Field(FORM *form);
118static int FN_Previous_Field(FORM *form);
119static int FE_New_Line(FORM *);
120static int FE_Delete_Previous(FORM *);
121
122/*----------------------------------------------------------------------------
123 Macro Definitions.
124
125 Some Remarks on that: I use the convention to use UPPERCASE for constants
126 defined by Macros. If I provide a macro as a kind of inline routine to
127 provide some logic, I use my Upper_Lower case style.
128 --------------------------------------------------------------------------*/
129
130/* Calculate the position of a single row in a field buffer */
131#define Position_Of_Row_In_Buffer(field,row) ((row)*(field)->dcols)
132
133/* Calculate start address for the fields buffer# N */
134#define Address_Of_Nth_Buffer(field,N) \
135 ((field)->buf + (N)*(1+Buffer_Length(field)))
136
137/* Calculate the start address of the row in the fields specified buffer# N */
138#define Address_Of_Row_In_Nth_Buffer(field,N,row) \
139 (Address_Of_Nth_Buffer(field,N) + Position_Of_Row_In_Buffer(field,row))
140
141/* Calculate the start address of the row in the fields primary buffer */
142#define Address_Of_Row_In_Buffer(field,row) \
143 Address_Of_Row_In_Nth_Buffer(field,0,row)
144
145/* Calculate the start address of the row in the forms current field
146 buffer# N */
147#define Address_Of_Current_Row_In_Nth_Buffer(form,N) \
148 Address_Of_Row_In_Nth_Buffer((form)->current,N,(form)->currow)
149
150/* Calculate the start address of the row in the forms current field
151 primary buffer */
152#define Address_Of_Current_Row_In_Buffer(form) \
153 Address_Of_Current_Row_In_Nth_Buffer(form,0)
154
155/* Calculate the address of the cursor in the forms current field
156 primary buffer */
157#define Address_Of_Current_Position_In_Nth_Buffer(form,N) \
158 (Address_Of_Current_Row_In_Nth_Buffer(form,N) + (form)->curcol)
159
160/* Calculate the address of the cursor in the forms current field
161 buffer# N */
162#define Address_Of_Current_Position_In_Buffer(form) \
163 Address_Of_Current_Position_In_Nth_Buffer(form,0)
164
165/* Logic to decide whether or not a field is actually a field with
166 vertical or horizontal scrolling */
167#define Is_Scroll_Field(field) \
168 (((field)->drows > (field)->rows) || \
169 ((field)->dcols > (field)->cols))
170
171/* Logic to decide whether or not a field needs to have an individual window
172 instead of a derived window because it contains invisible parts.
173 This is true for non-public fields and for scrollable fields. */
174#define Has_Invisible_Parts(field) \
175 (!((field)->opts & O_PUBLIC) || \
176 Is_Scroll_Field(field))
177
178/* Logic to decide whether or not a field needs justification */
179#define Justification_Allowed(field) \
180 (((field)->just != NO_JUSTIFICATION) && \
181 (Single_Line_Field(field)) && \
182 (((field)->dcols == (field)->cols) && \
183 ((field)->opts & O_STATIC)) )
184
185/* Logic to determine whether or not a dynamic field may still grow */
186#define Growable(field) ((field)->status & _MAY_GROW)
187
188/* Macro to set the attributes for a fields window */
189#define Set_Field_Window_Attributes(field,win) \
190( wbkgdset((win),(chtype)((field)->pad | (field)->back)), \
191 wattrset((win),(field)->fore) )
192
193/* Logic to decide whether or not a field really appears on the form */
194#define Field_Really_Appears(field) \
195 ((field->form) &&\
196 (field->form->status & _POSTED) &&\
197 (field->opts & O_VISIBLE) &&\
198 (field->page == field->form->curpage))
199
200/* Logic to determine whether or not we are on the first position in the
201 current field */
202#define First_Position_In_Current_Field(form) \
203 (((form)->currow==0) && ((form)->curcol==0))
204
205#define Minimum(a,b) (((a)<=(b)) ? (a) : (b))
206#define Maximum(a,b) (((a)>=(b)) ? (a) : (b))
207
208/*----------------------------------------------------------------------------
209 Useful constants
210 --------------------------------------------------------------------------*/
211static FIELD_CELL myBLANK = BLANK;
212static FIELD_CELL myZEROS;
213
214#ifdef TRACE
215static void
216check_pos(FORM *form, int lineno)
217{
218 int y, x;
219
220 if (form && form->w)
221 {
222 getyx(form->w, y, x);
223 if (y != form->currow || x != form->curcol)
224 {
225 T(("CHECKPOS %s@%d have position %d,%d vs want %d,%d",
226 __FILE__, lineno,
227 y, x,
228 form->currow, form->curcol));
229 }
230 }
231}
232#define CHECKPOS(form) check_pos(form, __LINE__)
233#else
234#define CHECKPOS(form) /* nothing */
235#endif
236
237/*----------------------------------------------------------------------------
238 Wide-character special functions
239 --------------------------------------------------------------------------*/
240#if USE_WIDEC_SUPPORT
241/* like winsnstr */
242static int
243wins_wchnstr(WINDOW *w, cchar_t *s, int n)
244{
245 int code = ERR;
246 int y, x;
247
248 while (n-- > 0)
249 {
250 getyx(w, y, x);
251 if ((code = wins_wch(w, s++)) != OK)
252 break;
253 if ((code = wmove(w, y, x + 1)) != OK)
254 break;
255 }
256 return code;
257}
258
259/* win_wchnstr is inconsistent with winnstr, since it returns OK rather than
260 * the number of items transferred.
261 */
262static int
263fix_wchnstr(WINDOW *w, cchar_t *s, int n)
264{
265 int x;
266
267 win_wchnstr(w, s, n);
268 /*
269 * This function is used to extract the text only from the window.
270 * Strip attributes and color from the string so they will not be added
271 * back when copying the string to the window.
272 */
273 for (x = 0; x < n; ++x)
274 {
275 RemAttr(s[x], A_ATTRIBUTES);
276 SetPair(s[x], 0);
277 }
278 return n;
279}
280
281/*
282 * Returns the column of the base of the given cell.
283 */
284static int
285cell_base(WINDOW *win, int y, int x)
286{
287 int result = x;
288
289 while (LEGALYX(win, y, x))
290 {
291 cchar_t *data = &(win->_line[y].text[x]);
292
293 if (isWidecBase(CHDEREF(data)) || !isWidecExt(CHDEREF(data)))
294 {
295 result = x;
296 break;
297 }
298 --x;
299 }
300 return result;
301}
302
303/*
304 * Returns the number of columns needed for the given cell in a window.
305 */
306static int
307cell_width(WINDOW *win, int y, int x)
308{
309 int result = 1;
310
311 if (LEGALYX(win, y, x))
312 {
313 cchar_t *data = &(win->_line[y].text[x]);
314
315 if (isWidecExt(CHDEREF(data)))
316 {
317 /* recur, providing the number of columns to the next character */
318 result = cell_width(win, y, x - 1);
319 }
320 else
321 {
322 result = wcwidth(CharOf(CHDEREF(data)));
323 }
324 }
325 return result;
326}
327
328/*
329 * There is no wide-character function such as wdel_wch(), so we must find
330 * all of the cells that comprise a multi-column character and delete them
331 * one-by-one.
332 */
333static void
334delete_char(FORM *form)
335{
336 int cells = cell_width(form->w, form->currow, form->curcol);
337
338 form->curcol = cell_base(form->w, form->currow, form->curcol);
339 wmove(form->w, form->currow, form->curcol);
340 while (cells-- > 0)
341 {
342 wdelch(form->w);
343 }
344}
345#define DeleteChar(form) delete_char(form)
346#else
347#define DeleteChar(form) \
348 wmove((form)->w, (form)->currow, (form)->curcol), \
349 wdelch((form)->w)
350#endif
351
352/*---------------------------------------------------------------------------
353| Facility : libnform
354| Function : static char *Get_Start_Of_Data(char * buf, int blen)
355|
356| Description : Return pointer to first non-blank position in buffer.
357| If buffer is empty return pointer to buffer itself.
358|
359| Return Values : Pointer to first non-blank position in buffer
360+--------------------------------------------------------------------------*/
361NCURSES_INLINE static FIELD_CELL *
362Get_Start_Of_Data(FIELD_CELL *buf, int blen)
363{
364 FIELD_CELL *p = buf;
365 FIELD_CELL *end = &buf[blen];
366
367 assert(buf && blen >= 0);
368 while ((p < end) && ISBLANK(*p))
369 p++;
370 return ((p == end) ? buf : p);
371}
372
373/*---------------------------------------------------------------------------
374| Facility : libnform
375| Function : static char *After_End_Of_Data(char * buf, int blen)
376|
377| Description : Return pointer after last non-blank position in buffer.
378| If buffer is empty, return pointer to buffer itself.
379|
380| Return Values : Pointer to position after last non-blank position in
381| buffer.
382+--------------------------------------------------------------------------*/
383NCURSES_INLINE static FIELD_CELL *
384After_End_Of_Data(FIELD_CELL *buf, int blen)
385{
386 FIELD_CELL *p = &buf[blen];
387
388 assert(buf && blen >= 0);
389 while ((p > buf) && ISBLANK(p[-1]))
390 p--;
391 return (p);
392}
393
394/*---------------------------------------------------------------------------
395| Facility : libnform
396| Function : static char *Get_First_Whitespace_Character(
397| char * buf, int blen)
398|
399| Description : Position to the first whitespace character.
400|
401| Return Values : Pointer to first whitespace character in buffer.
402+--------------------------------------------------------------------------*/
403NCURSES_INLINE static FIELD_CELL *
404Get_First_Whitespace_Character(FIELD_CELL *buf, int blen)
405{
406 FIELD_CELL *p = buf;
407 FIELD_CELL *end = &p[blen];
408
409 assert(buf && blen >= 0);
410 while ((p < end) && !ISBLANK(*p))
411 p++;
412 return ((p == end) ? buf : p);
413}
414
415/*---------------------------------------------------------------------------
416| Facility : libnform
417| Function : static char *After_Last_Whitespace_Character(
418| char * buf, int blen)
419|
420| Description : Get the position after the last whitespace character.
421|
422| Return Values : Pointer to position after last whitespace character in
423| buffer.
424+--------------------------------------------------------------------------*/
425NCURSES_INLINE static FIELD_CELL *
426After_Last_Whitespace_Character(FIELD_CELL *buf, int blen)
427{
428 FIELD_CELL *p = &buf[blen];
429
430 assert(buf && blen >= 0);
431 while ((p > buf) && !ISBLANK(p[-1]))
432 p--;
433 return (p);
434}
435
436/* Set this to 1 to use the div_t version. This is a good idea if your
437 compiler has an intrinsic div() support. Unfortunately GNU-C has it
438 not yet.
439 N.B.: This only works if form->curcol follows immediately form->currow
440 and both are of type int.
441*/
442#define USE_DIV_T (0)
443
444/*---------------------------------------------------------------------------
445| Facility : libnform
446| Function : static void Adjust_Cursor_Position(
447| FORM * form, const char * pos)
448|
449| Description : Set current row and column of the form to values
450| corresponding to the buffer position.
451|
452| Return Values : -
453+--------------------------------------------------------------------------*/
454NCURSES_INLINE static void
455Adjust_Cursor_Position(FORM *form, const FIELD_CELL *pos)
456{
457 FIELD *field;
458 int idx;
459
460 field = form->current;
461 assert(pos >= field->buf && field->dcols > 0);
462 idx = (int)(pos - field->buf);
463#if USE_DIV_T
464 *((div_t *) & (form->currow)) = div(idx, field->dcols);
465#else
466 form->currow = idx / field->dcols;
467 form->curcol = idx - field->cols * form->currow;
468#endif
469 if (field->drows < form->currow)
470 form->currow = 0;
471}
472
473/*---------------------------------------------------------------------------
474| Facility : libnform
475| Function : static void Buffer_To_Window(
476| const FIELD * field,
477| WINDOW * win)
478|
479| Description : Copy the buffer to the window. If it is a multi-line
480| field, the buffer is split to the lines of the
481| window without any editing.
482|
483| Return Values : -
484+--------------------------------------------------------------------------*/
485static void
486Buffer_To_Window(const FIELD *field, WINDOW *win)
487{
488 int width, height;
489 int y, x;
490 int len;
491 int row;
492 FIELD_CELL *pBuffer;
493
494 assert(win && field);
495
496 getyx(win, y, x);
497 width = getmaxx(win);
498 height = getmaxy(win);
499
500 for (row = 0, pBuffer = field->buf;
501 row < height;
502 row++, pBuffer += width)
503 {
504 if ((len = (int)(After_End_Of_Data(pBuffer, width) - pBuffer)) > 0)
505 {
506 wmove(win, row, 0);
507 myADDNSTR(win, pBuffer, len);
508 }
509 }
510 wmove(win, y, x);
511}
512
513/*---------------------------------------------------------------------------
514| Facility : libnform
515| Function : static void Window_To_Buffer(
516| WINDOW * win,
517| FIELD * field)
518|
519| Description : Copy the content of the window into the buffer.
520| The multiple lines of a window are simply
521| concatenated into the buffer. Pad characters in
522| the window will be replaced by blanks in the buffer.
523|
524| Return Values : -
525+--------------------------------------------------------------------------*/
526static void
527Window_To_Buffer(WINDOW *win, FIELD *field)
528{
529 int pad;
530 int len = 0;
531 FIELD_CELL *p;
532 int row, height;
533
534 assert(win && field && field->buf);
535
536 pad = field->pad;
537 p = field->buf;
538 height = getmaxy(win);
539
540 for (row = 0; (row < height) && (row < field->drows); row++)
541 {
542 wmove(win, row, 0);
543 len += myINNSTR(win, p + len, field->dcols);
544 }
545 p[len] = myZEROS;
546
547 /* replace visual padding character by blanks in buffer */
548 if (pad != C_BLANK)
549 {
550 int i;
551
552 for (i = 0; i < len; i++, p++)
553 {
554 if ((unsigned long)CharOf(*p) == ChCharOf(pad)
555#if USE_WIDEC_SUPPORT
556 && p->chars[1] == 0
557#endif
558 )
559 *p = myBLANK;
560 }
561 }
562}
563
564/*---------------------------------------------------------------------------
565| Facility : libnform
566| Function : static void Synchronize_Buffer(FORM * form)
567|
568| Description : If there was a change, copy the content of the
569| window into the buffer, so the buffer is synchronized
570| with the windows content. We have to indicate that the
571| buffer needs validation due to the change.
572|
573| Return Values : -
574+--------------------------------------------------------------------------*/
575NCURSES_INLINE static void
576Synchronize_Buffer(FORM *form)
577{
578 if (form->status & _WINDOW_MODIFIED)
579 {
580 form->status &= ~_WINDOW_MODIFIED;
581 form->status |= _FCHECK_REQUIRED;
582 Window_To_Buffer(form->w, form->current);
583 wmove(form->w, form->currow, form->curcol);
584 }
585}
586
587/*---------------------------------------------------------------------------
588| Facility : libnform
589| Function : static bool Field_Grown( FIELD *field, int amount)
590|
591| Description : This function is called for growable dynamic fields
592| only. It has to increase the buffers and to allocate
593| a new window for this field.
594| This function has the side effect to set a new
595| field-buffer pointer, the dcols and drows values
596| as well as a new current Window for the field.
597|
598| Return Values : TRUE - field successfully increased
599| FALSE - there was some error
600+--------------------------------------------------------------------------*/
601static bool
602Field_Grown(FIELD *field, int amount)
603{
604 bool result = FALSE;
605
606 if (field && Growable(field))
607 {
608 bool single_line_field = Single_Line_Field(field);
609 int old_buflen = Buffer_Length(field);
610 int new_buflen;
611 int old_dcols = field->dcols;
612 int old_drows = field->drows;
613 FIELD_CELL *oldbuf = field->buf;
614 FIELD_CELL *newbuf;
615
616 int growth;
617 FORM *form = field->form;
618 bool need_visual_update = ((form != (FORM *)0) &&
619 (form->status & _POSTED) &&
620 (form->current == field));
621
622 if (need_visual_update)
623 Synchronize_Buffer(form);
624
625 if (single_line_field)
626 {
627 growth = field->cols * amount;
628 if (field->maxgrow)
629 growth = Minimum(field->maxgrow - field->dcols, growth);
630 field->dcols += growth;
631 if (field->dcols == field->maxgrow)
632 field->status &= ~_MAY_GROW;
633 }
634 else
635 {
636 growth = (field->rows + field->nrow) * amount;
637 if (field->maxgrow)
638 growth = Minimum(field->maxgrow - field->drows, growth);
639 field->drows += growth;
640 if (field->drows == field->maxgrow)
641 field->status &= ~_MAY_GROW;
642 }
643 /* drows, dcols changed, so we get really the new buffer length */
644 new_buflen = Buffer_Length(field);
645 newbuf = (FIELD_CELL *)malloc(Total_Buffer_Size(field));
646 if (!newbuf)
647 {
648 /* restore to previous state */
649 field->dcols = old_dcols;
650 field->drows = old_drows;
651 if ((single_line_field && (field->dcols != field->maxgrow)) ||
652 (!single_line_field && (field->drows != field->maxgrow)))
653 field->status |= _MAY_GROW;
654 }
655 else
656 {
657 /* Copy all the buffers. This is the reason why we can't just use
658 * realloc().
659 */
660 int i, j;
661 FIELD_CELL *old_bp;
662 FIELD_CELL *new_bp;
663
664 result = TRUE; /* allow sharing of recovery on failure */
665
666 T((T_CREATE("fieldcell %p"), newbuf));
667 field->buf = newbuf;
668 for (i = 0; i <= field->nbuf; i++)
669 {
670 new_bp = Address_Of_Nth_Buffer(field, i);
671 old_bp = oldbuf + i * (1 + old_buflen);
672 for (j = 0; j < old_buflen; ++j)
673 new_bp[j] = old_bp[j];
674 while (j < new_buflen)
675 new_bp[j++] = myBLANK;
676 new_bp[new_buflen] = myZEROS;
677 }
678
| 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 Essentially 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 Essentially 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/*
81Some options that may effect compatibility in behavior to SVr4 forms,
82but they are here to allow a more intuitive and user friendly behavior of
83our form implementation. This doesn't affect the API, so we feel it is
84uncritical.
85
86The initial implementation tries to stay very close with the behavior
87of the original SVr4 implementation, although in some areas it is quite
88clear that this isn't the most appropriate way. As far as possible this
89sources will allow you to build a forms lib that behaves quite similar
90to SVr4, but now and in the future we will give you better options.
91Perhaps at some time we will make this configurable at runtime.
92*/
93
94/* Implement a more user-friendly previous/next word behavior */
95#define FRIENDLY_PREV_NEXT_WORD (1)
96/* Fix the wrong behavior 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#if USE_WIDEC_SUPPORT
102#define myADDNSTR(w, s, n) wadd_wchnstr(w, s, n)
103#define myINSNSTR(w, s, n) wins_wchnstr(w, s, n)
104#define myINNSTR(w, s, n) fix_wchnstr(w, s, n)
105#define myWCWIDTH(w, y, x) cell_width(w, y, x)
106#else
107#define myADDNSTR(w, s, n) waddnstr(w, s, n)
108#define myINSNSTR(w, s, n) winsnstr(w, s, n)
109#define myINNSTR(w, s, n) winnstr(w, s, n)
110#define myWCWIDTH(w, y, x) 1
111#endif
112
113/*----------------------------------------------------------------------------
114 Forward references to some internally used static functions
115 --------------------------------------------------------------------------*/
116static int Inter_Field_Navigation(int (*const fct) (FORM *), FORM *form);
117static int FN_Next_Field(FORM *form);
118static int FN_Previous_Field(FORM *form);
119static int FE_New_Line(FORM *);
120static int FE_Delete_Previous(FORM *);
121
122/*----------------------------------------------------------------------------
123 Macro Definitions.
124
125 Some Remarks on that: I use the convention to use UPPERCASE for constants
126 defined by Macros. If I provide a macro as a kind of inline routine to
127 provide some logic, I use my Upper_Lower case style.
128 --------------------------------------------------------------------------*/
129
130/* Calculate the position of a single row in a field buffer */
131#define Position_Of_Row_In_Buffer(field,row) ((row)*(field)->dcols)
132
133/* Calculate start address for the fields buffer# N */
134#define Address_Of_Nth_Buffer(field,N) \
135 ((field)->buf + (N)*(1+Buffer_Length(field)))
136
137/* Calculate the start address of the row in the fields specified buffer# N */
138#define Address_Of_Row_In_Nth_Buffer(field,N,row) \
139 (Address_Of_Nth_Buffer(field,N) + Position_Of_Row_In_Buffer(field,row))
140
141/* Calculate the start address of the row in the fields primary buffer */
142#define Address_Of_Row_In_Buffer(field,row) \
143 Address_Of_Row_In_Nth_Buffer(field,0,row)
144
145/* Calculate the start address of the row in the forms current field
146 buffer# N */
147#define Address_Of_Current_Row_In_Nth_Buffer(form,N) \
148 Address_Of_Row_In_Nth_Buffer((form)->current,N,(form)->currow)
149
150/* Calculate the start address of the row in the forms current field
151 primary buffer */
152#define Address_Of_Current_Row_In_Buffer(form) \
153 Address_Of_Current_Row_In_Nth_Buffer(form,0)
154
155/* Calculate the address of the cursor in the forms current field
156 primary buffer */
157#define Address_Of_Current_Position_In_Nth_Buffer(form,N) \
158 (Address_Of_Current_Row_In_Nth_Buffer(form,N) + (form)->curcol)
159
160/* Calculate the address of the cursor in the forms current field
161 buffer# N */
162#define Address_Of_Current_Position_In_Buffer(form) \
163 Address_Of_Current_Position_In_Nth_Buffer(form,0)
164
165/* Logic to decide whether or not a field is actually a field with
166 vertical or horizontal scrolling */
167#define Is_Scroll_Field(field) \
168 (((field)->drows > (field)->rows) || \
169 ((field)->dcols > (field)->cols))
170
171/* Logic to decide whether or not a field needs to have an individual window
172 instead of a derived window because it contains invisible parts.
173 This is true for non-public fields and for scrollable fields. */
174#define Has_Invisible_Parts(field) \
175 (!((field)->opts & O_PUBLIC) || \
176 Is_Scroll_Field(field))
177
178/* Logic to decide whether or not a field needs justification */
179#define Justification_Allowed(field) \
180 (((field)->just != NO_JUSTIFICATION) && \
181 (Single_Line_Field(field)) && \
182 (((field)->dcols == (field)->cols) && \
183 ((field)->opts & O_STATIC)) )
184
185/* Logic to determine whether or not a dynamic field may still grow */
186#define Growable(field) ((field)->status & _MAY_GROW)
187
188/* Macro to set the attributes for a fields window */
189#define Set_Field_Window_Attributes(field,win) \
190( wbkgdset((win),(chtype)((field)->pad | (field)->back)), \
191 wattrset((win),(field)->fore) )
192
193/* Logic to decide whether or not a field really appears on the form */
194#define Field_Really_Appears(field) \
195 ((field->form) &&\
196 (field->form->status & _POSTED) &&\
197 (field->opts & O_VISIBLE) &&\
198 (field->page == field->form->curpage))
199
200/* Logic to determine whether or not we are on the first position in the
201 current field */
202#define First_Position_In_Current_Field(form) \
203 (((form)->currow==0) && ((form)->curcol==0))
204
205#define Minimum(a,b) (((a)<=(b)) ? (a) : (b))
206#define Maximum(a,b) (((a)>=(b)) ? (a) : (b))
207
208/*----------------------------------------------------------------------------
209 Useful constants
210 --------------------------------------------------------------------------*/
211static FIELD_CELL myBLANK = BLANK;
212static FIELD_CELL myZEROS;
213
214#ifdef TRACE
215static void
216check_pos(FORM *form, int lineno)
217{
218 int y, x;
219
220 if (form && form->w)
221 {
222 getyx(form->w, y, x);
223 if (y != form->currow || x != form->curcol)
224 {
225 T(("CHECKPOS %s@%d have position %d,%d vs want %d,%d",
226 __FILE__, lineno,
227 y, x,
228 form->currow, form->curcol));
229 }
230 }
231}
232#define CHECKPOS(form) check_pos(form, __LINE__)
233#else
234#define CHECKPOS(form) /* nothing */
235#endif
236
237/*----------------------------------------------------------------------------
238 Wide-character special functions
239 --------------------------------------------------------------------------*/
240#if USE_WIDEC_SUPPORT
241/* like winsnstr */
242static int
243wins_wchnstr(WINDOW *w, cchar_t *s, int n)
244{
245 int code = ERR;
246 int y, x;
247
248 while (n-- > 0)
249 {
250 getyx(w, y, x);
251 if ((code = wins_wch(w, s++)) != OK)
252 break;
253 if ((code = wmove(w, y, x + 1)) != OK)
254 break;
255 }
256 return code;
257}
258
259/* win_wchnstr is inconsistent with winnstr, since it returns OK rather than
260 * the number of items transferred.
261 */
262static int
263fix_wchnstr(WINDOW *w, cchar_t *s, int n)
264{
265 int x;
266
267 win_wchnstr(w, s, n);
268 /*
269 * This function is used to extract the text only from the window.
270 * Strip attributes and color from the string so they will not be added
271 * back when copying the string to the window.
272 */
273 for (x = 0; x < n; ++x)
274 {
275 RemAttr(s[x], A_ATTRIBUTES);
276 SetPair(s[x], 0);
277 }
278 return n;
279}
280
281/*
282 * Returns the column of the base of the given cell.
283 */
284static int
285cell_base(WINDOW *win, int y, int x)
286{
287 int result = x;
288
289 while (LEGALYX(win, y, x))
290 {
291 cchar_t *data = &(win->_line[y].text[x]);
292
293 if (isWidecBase(CHDEREF(data)) || !isWidecExt(CHDEREF(data)))
294 {
295 result = x;
296 break;
297 }
298 --x;
299 }
300 return result;
301}
302
303/*
304 * Returns the number of columns needed for the given cell in a window.
305 */
306static int
307cell_width(WINDOW *win, int y, int x)
308{
309 int result = 1;
310
311 if (LEGALYX(win, y, x))
312 {
313 cchar_t *data = &(win->_line[y].text[x]);
314
315 if (isWidecExt(CHDEREF(data)))
316 {
317 /* recur, providing the number of columns to the next character */
318 result = cell_width(win, y, x - 1);
319 }
320 else
321 {
322 result = wcwidth(CharOf(CHDEREF(data)));
323 }
324 }
325 return result;
326}
327
328/*
329 * There is no wide-character function such as wdel_wch(), so we must find
330 * all of the cells that comprise a multi-column character and delete them
331 * one-by-one.
332 */
333static void
334delete_char(FORM *form)
335{
336 int cells = cell_width(form->w, form->currow, form->curcol);
337
338 form->curcol = cell_base(form->w, form->currow, form->curcol);
339 wmove(form->w, form->currow, form->curcol);
340 while (cells-- > 0)
341 {
342 wdelch(form->w);
343 }
344}
345#define DeleteChar(form) delete_char(form)
346#else
347#define DeleteChar(form) \
348 wmove((form)->w, (form)->currow, (form)->curcol), \
349 wdelch((form)->w)
350#endif
351
352/*---------------------------------------------------------------------------
353| Facility : libnform
354| Function : static char *Get_Start_Of_Data(char * buf, int blen)
355|
356| Description : Return pointer to first non-blank position in buffer.
357| If buffer is empty return pointer to buffer itself.
358|
359| Return Values : Pointer to first non-blank position in buffer
360+--------------------------------------------------------------------------*/
361NCURSES_INLINE static FIELD_CELL *
362Get_Start_Of_Data(FIELD_CELL *buf, int blen)
363{
364 FIELD_CELL *p = buf;
365 FIELD_CELL *end = &buf[blen];
366
367 assert(buf && blen >= 0);
368 while ((p < end) && ISBLANK(*p))
369 p++;
370 return ((p == end) ? buf : p);
371}
372
373/*---------------------------------------------------------------------------
374| Facility : libnform
375| Function : static char *After_End_Of_Data(char * buf, int blen)
376|
377| Description : Return pointer after last non-blank position in buffer.
378| If buffer is empty, return pointer to buffer itself.
379|
380| Return Values : Pointer to position after last non-blank position in
381| buffer.
382+--------------------------------------------------------------------------*/
383NCURSES_INLINE static FIELD_CELL *
384After_End_Of_Data(FIELD_CELL *buf, int blen)
385{
386 FIELD_CELL *p = &buf[blen];
387
388 assert(buf && blen >= 0);
389 while ((p > buf) && ISBLANK(p[-1]))
390 p--;
391 return (p);
392}
393
394/*---------------------------------------------------------------------------
395| Facility : libnform
396| Function : static char *Get_First_Whitespace_Character(
397| char * buf, int blen)
398|
399| Description : Position to the first whitespace character.
400|
401| Return Values : Pointer to first whitespace character in buffer.
402+--------------------------------------------------------------------------*/
403NCURSES_INLINE static FIELD_CELL *
404Get_First_Whitespace_Character(FIELD_CELL *buf, int blen)
405{
406 FIELD_CELL *p = buf;
407 FIELD_CELL *end = &p[blen];
408
409 assert(buf && blen >= 0);
410 while ((p < end) && !ISBLANK(*p))
411 p++;
412 return ((p == end) ? buf : p);
413}
414
415/*---------------------------------------------------------------------------
416| Facility : libnform
417| Function : static char *After_Last_Whitespace_Character(
418| char * buf, int blen)
419|
420| Description : Get the position after the last whitespace character.
421|
422| Return Values : Pointer to position after last whitespace character in
423| buffer.
424+--------------------------------------------------------------------------*/
425NCURSES_INLINE static FIELD_CELL *
426After_Last_Whitespace_Character(FIELD_CELL *buf, int blen)
427{
428 FIELD_CELL *p = &buf[blen];
429
430 assert(buf && blen >= 0);
431 while ((p > buf) && !ISBLANK(p[-1]))
432 p--;
433 return (p);
434}
435
436/* Set this to 1 to use the div_t version. This is a good idea if your
437 compiler has an intrinsic div() support. Unfortunately GNU-C has it
438 not yet.
439 N.B.: This only works if form->curcol follows immediately form->currow
440 and both are of type int.
441*/
442#define USE_DIV_T (0)
443
444/*---------------------------------------------------------------------------
445| Facility : libnform
446| Function : static void Adjust_Cursor_Position(
447| FORM * form, const char * pos)
448|
449| Description : Set current row and column of the form to values
450| corresponding to the buffer position.
451|
452| Return Values : -
453+--------------------------------------------------------------------------*/
454NCURSES_INLINE static void
455Adjust_Cursor_Position(FORM *form, const FIELD_CELL *pos)
456{
457 FIELD *field;
458 int idx;
459
460 field = form->current;
461 assert(pos >= field->buf && field->dcols > 0);
462 idx = (int)(pos - field->buf);
463#if USE_DIV_T
464 *((div_t *) & (form->currow)) = div(idx, field->dcols);
465#else
466 form->currow = idx / field->dcols;
467 form->curcol = idx - field->cols * form->currow;
468#endif
469 if (field->drows < form->currow)
470 form->currow = 0;
471}
472
473/*---------------------------------------------------------------------------
474| Facility : libnform
475| Function : static void Buffer_To_Window(
476| const FIELD * field,
477| WINDOW * win)
478|
479| Description : Copy the buffer to the window. If it is a multi-line
480| field, the buffer is split to the lines of the
481| window without any editing.
482|
483| Return Values : -
484+--------------------------------------------------------------------------*/
485static void
486Buffer_To_Window(const FIELD *field, WINDOW *win)
487{
488 int width, height;
489 int y, x;
490 int len;
491 int row;
492 FIELD_CELL *pBuffer;
493
494 assert(win && field);
495
496 getyx(win, y, x);
497 width = getmaxx(win);
498 height = getmaxy(win);
499
500 for (row = 0, pBuffer = field->buf;
501 row < height;
502 row++, pBuffer += width)
503 {
504 if ((len = (int)(After_End_Of_Data(pBuffer, width) - pBuffer)) > 0)
505 {
506 wmove(win, row, 0);
507 myADDNSTR(win, pBuffer, len);
508 }
509 }
510 wmove(win, y, x);
511}
512
513/*---------------------------------------------------------------------------
514| Facility : libnform
515| Function : static void Window_To_Buffer(
516| WINDOW * win,
517| FIELD * field)
518|
519| Description : Copy the content of the window into the buffer.
520| The multiple lines of a window are simply
521| concatenated into the buffer. Pad characters in
522| the window will be replaced by blanks in the buffer.
523|
524| Return Values : -
525+--------------------------------------------------------------------------*/
526static void
527Window_To_Buffer(WINDOW *win, FIELD *field)
528{
529 int pad;
530 int len = 0;
531 FIELD_CELL *p;
532 int row, height;
533
534 assert(win && field && field->buf);
535
536 pad = field->pad;
537 p = field->buf;
538 height = getmaxy(win);
539
540 for (row = 0; (row < height) && (row < field->drows); row++)
541 {
542 wmove(win, row, 0);
543 len += myINNSTR(win, p + len, field->dcols);
544 }
545 p[len] = myZEROS;
546
547 /* replace visual padding character by blanks in buffer */
548 if (pad != C_BLANK)
549 {
550 int i;
551
552 for (i = 0; i < len; i++, p++)
553 {
554 if ((unsigned long)CharOf(*p) == ChCharOf(pad)
555#if USE_WIDEC_SUPPORT
556 && p->chars[1] == 0
557#endif
558 )
559 *p = myBLANK;
560 }
561 }
562}
563
564/*---------------------------------------------------------------------------
565| Facility : libnform
566| Function : static void Synchronize_Buffer(FORM * form)
567|
568| Description : If there was a change, copy the content of the
569| window into the buffer, so the buffer is synchronized
570| with the windows content. We have to indicate that the
571| buffer needs validation due to the change.
572|
573| Return Values : -
574+--------------------------------------------------------------------------*/
575NCURSES_INLINE static void
576Synchronize_Buffer(FORM *form)
577{
578 if (form->status & _WINDOW_MODIFIED)
579 {
580 form->status &= ~_WINDOW_MODIFIED;
581 form->status |= _FCHECK_REQUIRED;
582 Window_To_Buffer(form->w, form->current);
583 wmove(form->w, form->currow, form->curcol);
584 }
585}
586
587/*---------------------------------------------------------------------------
588| Facility : libnform
589| Function : static bool Field_Grown( FIELD *field, int amount)
590|
591| Description : This function is called for growable dynamic fields
592| only. It has to increase the buffers and to allocate
593| a new window for this field.
594| This function has the side effect to set a new
595| field-buffer pointer, the dcols and drows values
596| as well as a new current Window for the field.
597|
598| Return Values : TRUE - field successfully increased
599| FALSE - there was some error
600+--------------------------------------------------------------------------*/
601static bool
602Field_Grown(FIELD *field, int amount)
603{
604 bool result = FALSE;
605
606 if (field && Growable(field))
607 {
608 bool single_line_field = Single_Line_Field(field);
609 int old_buflen = Buffer_Length(field);
610 int new_buflen;
611 int old_dcols = field->dcols;
612 int old_drows = field->drows;
613 FIELD_CELL *oldbuf = field->buf;
614 FIELD_CELL *newbuf;
615
616 int growth;
617 FORM *form = field->form;
618 bool need_visual_update = ((form != (FORM *)0) &&
619 (form->status & _POSTED) &&
620 (form->current == field));
621
622 if (need_visual_update)
623 Synchronize_Buffer(form);
624
625 if (single_line_field)
626 {
627 growth = field->cols * amount;
628 if (field->maxgrow)
629 growth = Minimum(field->maxgrow - field->dcols, growth);
630 field->dcols += growth;
631 if (field->dcols == field->maxgrow)
632 field->status &= ~_MAY_GROW;
633 }
634 else
635 {
636 growth = (field->rows + field->nrow) * amount;
637 if (field->maxgrow)
638 growth = Minimum(field->maxgrow - field->drows, growth);
639 field->drows += growth;
640 if (field->drows == field->maxgrow)
641 field->status &= ~_MAY_GROW;
642 }
643 /* drows, dcols changed, so we get really the new buffer length */
644 new_buflen = Buffer_Length(field);
645 newbuf = (FIELD_CELL *)malloc(Total_Buffer_Size(field));
646 if (!newbuf)
647 {
648 /* restore to previous state */
649 field->dcols = old_dcols;
650 field->drows = old_drows;
651 if ((single_line_field && (field->dcols != field->maxgrow)) ||
652 (!single_line_field && (field->drows != field->maxgrow)))
653 field->status |= _MAY_GROW;
654 }
655 else
656 {
657 /* Copy all the buffers. This is the reason why we can't just use
658 * realloc().
659 */
660 int i, j;
661 FIELD_CELL *old_bp;
662 FIELD_CELL *new_bp;
663
664 result = TRUE; /* allow sharing of recovery on failure */
665
666 T((T_CREATE("fieldcell %p"), newbuf));
667 field->buf = newbuf;
668 for (i = 0; i <= field->nbuf; i++)
669 {
670 new_bp = Address_Of_Nth_Buffer(field, i);
671 old_bp = oldbuf + i * (1 + old_buflen);
672 for (j = 0; j < old_buflen; ++j)
673 new_bp[j] = old_bp[j];
674 while (j < new_buflen)
675 new_bp[j++] = myBLANK;
676 new_bp[new_buflen] = myZEROS;
677 }
678
|
680 if (wresize(field->working, 1, Buffer_Length(field) + 1) == ERR)
681 result = FALSE;
682#endif
683
684 if (need_visual_update && result)
685 {
686 WINDOW *new_window = newpad(field->drows, field->dcols);
687
688 if (new_window != 0)
689 {
690 assert(form != (FORM *)0);
691 if (form->w)
692 delwin(form->w);
693 form->w = new_window;
694 Set_Field_Window_Attributes(field, form->w);
695 werase(form->w);
696 Buffer_To_Window(field, form->w);
697 untouchwin(form->w);
698 wmove(form->w, form->currow, form->curcol);
699 }
700 else
701 result = FALSE;
702 }
703
704 if (result)
705 {
706 free(oldbuf);
707 /* reflect changes in linked fields */
708 if (field != field->link)
709 {
710 FIELD *linked_field;
711
712 for (linked_field = field->link;
713 linked_field != field;
714 linked_field = linked_field->link)
715 {
716 linked_field->buf = field->buf;
717 linked_field->drows = field->drows;
718 linked_field->dcols = field->dcols;
719 }
720 }
721 }
722 else
723 {
724 /* restore old state */
725 field->dcols = old_dcols;
726 field->drows = old_drows;
727 field->buf = oldbuf;
728 if ((single_line_field &&
729 (field->dcols != field->maxgrow)) ||
730 (!single_line_field &&
731 (field->drows != field->maxgrow)))
732 field->status |= _MAY_GROW;
733 free(newbuf);
734 }
735 }
736 }
737 return (result);
738}
739
740#ifdef NCURSES_MOUSE_VERSION
741/*---------------------------------------------------------------------------
742| Facility : libnform
743| Function : int Field_encloses(FIELD *field, int ry, int rx)
744|
745| Description : Check if the given coordinates lie within the given field.
746|
747| Return Values : E_OK - success
748| E_BAD_ARGUMENT - invalid form pointer
749| E_SYSTEM_ERROR - form has no current field or
750| field-window
751+--------------------------------------------------------------------------*/
752static int
753Field_encloses(FIELD *field, int ry, int rx)
754{
755 T((T_CALLED("Field_encloses(%p)"), field));
756 if (field != 0
757 && field->frow <= ry
758 && (field->frow + field->rows) > ry
759 && field->fcol <= rx
760 && (field->fcol + field->cols) > rx)
761 {
762 RETURN(E_OK);
763 }
764 RETURN(E_INVALID_FIELD);
765}
766#endif
767
768/*---------------------------------------------------------------------------
769| Facility : libnform
770| Function : int _nc_Position_Form_Cursor(FORM * form)
771|
772| Description : Position the cursor in the window for the current
773| field to be in sync. with the currow and curcol
774| values.
775|
776| Return Values : E_OK - success
777| E_BAD_ARGUMENT - invalid form pointer
778| E_SYSTEM_ERROR - form has no current field or
779| field-window
780+--------------------------------------------------------------------------*/
781NCURSES_EXPORT(int)
782_nc_Position_Form_Cursor(FORM *form)
783{
784 FIELD *field;
785 WINDOW *formwin;
786
787 if (!form)
788 return (E_BAD_ARGUMENT);
789
790 if (!form->w || !form->current)
791 return (E_SYSTEM_ERROR);
792
793 field = form->current;
794 formwin = Get_Form_Window(form);
795
796 wmove(form->w, form->currow, form->curcol);
797 if (Has_Invisible_Parts(field))
798 {
799 /* in this case fieldwin isn't derived from formwin, so we have
800 to move the cursor in formwin by hand... */
801 wmove(formwin,
802 field->frow + form->currow - form->toprow,
803 field->fcol + form->curcol - form->begincol);
804 wcursyncup(formwin);
805 }
806 else
807 wcursyncup(form->w);
808 return (E_OK);
809}
810
811/*---------------------------------------------------------------------------
812| Facility : libnform
813| Function : int _nc_Refresh_Current_Field(FORM * form)
814|
815| Description : Propagate the changes in the fields window to the
816| window of the form.
817|
818| Return Values : E_OK - on success
819| E_BAD_ARGUMENT - invalid form pointer
820| E_SYSTEM_ERROR - general error
821+--------------------------------------------------------------------------*/
822NCURSES_EXPORT(int)
823_nc_Refresh_Current_Field(FORM *form)
824{
825 WINDOW *formwin;
826 FIELD *field;
827
828 T((T_CALLED("_nc_Refresh_Current_Field(%p)"), form));
829
830 if (!form)
831 RETURN(E_BAD_ARGUMENT);
832
833 if (!form->w || !form->current)
834 RETURN(E_SYSTEM_ERROR);
835
836 field = form->current;
837 formwin = Get_Form_Window(form);
838
839 if (field->opts & O_PUBLIC)
840 {
841 if (Is_Scroll_Field(field))
842 {
843 /* Again, in this case the fieldwin isn't derived from formwin,
844 so we have to perform a copy operation. */
845 if (Single_Line_Field(field))
846 {
847 /* horizontal scrolling */
848 if (form->curcol < form->begincol)
849 form->begincol = form->curcol;
850 else
851 {
852 if (form->curcol >= (form->begincol + field->cols))
853 form->begincol = form->curcol - field->cols + 1;
854 }
855 copywin(form->w,
856 formwin,
857 0,
858 form->begincol,
859 field->frow,
860 field->fcol,
861 field->frow,
862 field->cols + field->fcol - 1,
863 0);
864 }
865 else
866 {
867 /* A multi-line, i.e. vertical scrolling field */
868 int row_after_bottom, first_modified_row, first_unmodified_row;
869
870 if (field->drows > field->rows)
871 {
872 row_after_bottom = form->toprow + field->rows;
873 if (form->currow < form->toprow)
874 {
875 form->toprow = form->currow;
876 field->status |= _NEWTOP;
877 }
878 if (form->currow >= row_after_bottom)
879 {
880 form->toprow = form->currow - field->rows + 1;
881 field->status |= _NEWTOP;
882 }
883 if (field->status & _NEWTOP)
884 {
885 /* means we have to copy whole range */
886 first_modified_row = form->toprow;
887 first_unmodified_row = first_modified_row + field->rows;
888 field->status &= ~_NEWTOP;
889 }
890 else
891 {
892 /* we try to optimize : finding the range of touched
893 lines */
894 first_modified_row = form->toprow;
895 while (first_modified_row < row_after_bottom)
896 {
897 if (is_linetouched(form->w, first_modified_row))
898 break;
899 first_modified_row++;
900 }
901 first_unmodified_row = first_modified_row;
902 while (first_unmodified_row < row_after_bottom)
903 {
904 if (!is_linetouched(form->w, first_unmodified_row))
905 break;
906 first_unmodified_row++;
907 }
908 }
909 }
910 else
911 {
912 first_modified_row = form->toprow;
913 first_unmodified_row = first_modified_row + field->rows;
914 }
915 if (first_unmodified_row != first_modified_row)
916 copywin(form->w,
917 formwin,
918 first_modified_row,
919 0,
920 field->frow + first_modified_row - form->toprow,
921 field->fcol,
922 field->frow + first_unmodified_row - form->toprow - 1,
923 field->cols + field->fcol - 1,
924 0);
925 }
926 wsyncup(formwin);
927 }
928 else
929 {
930 /* if the field-window is simply a derived window, i.e. contains no
931 * invisible parts, the whole thing is trivial
932 */
933 wsyncup(form->w);
934 }
935 }
936 untouchwin(form->w);
937 returnCode(_nc_Position_Form_Cursor(form));
938}
939
940/*---------------------------------------------------------------------------
941| Facility : libnform
942| Function : static void Perform_Justification(
943| FIELD * field,
944| WINDOW * win)
945|
946| Description : Output field with requested justification
947|
948| Return Values : -
949+--------------------------------------------------------------------------*/
950static void
951Perform_Justification(FIELD *field, WINDOW *win)
952{
953 FIELD_CELL *bp;
954 int len;
955 int col = 0;
956
957 bp = Get_Start_Of_Data(field->buf, Buffer_Length(field));
958 len = (int)(After_End_Of_Data(field->buf, Buffer_Length(field)) - bp);
959
960 if (len > 0)
961 {
962 assert(win && (field->drows == 1) && (field->dcols == field->cols));
963
964 switch (field->just)
965 {
966 case JUSTIFY_LEFT:
967 break;
968 case JUSTIFY_CENTER:
969 col = (field->cols - len) / 2;
970 break;
971 case JUSTIFY_RIGHT:
972 col = field->cols - len;
973 break;
974 default:
975 break;
976 }
977
978 wmove(win, 0, col);
979 myADDNSTR(win, bp, len);
980 }
981}
982
983/*---------------------------------------------------------------------------
984| Facility : libnform
985| Function : static void Undo_Justification(
986| FIELD * field,
987| WINDOW * win)
988|
989| Description : Display field without any justification, i.e.
990| left justified
991|
992| Return Values : -
993+--------------------------------------------------------------------------*/
994static void
995Undo_Justification(FIELD *field, WINDOW *win)
996{
997 FIELD_CELL *bp;
998 int len;
999
1000 bp = Get_Start_Of_Data(field->buf, Buffer_Length(field));
1001 len = (int)(After_End_Of_Data(field->buf, Buffer_Length(field)) - bp);
1002
1003 if (len > 0)
1004 {
1005 assert(win);
1006 wmove(win, 0, 0);
1007 myADDNSTR(win, bp, len);
1008 }
1009}
1010
1011/*---------------------------------------------------------------------------
1012| Facility : libnform
1013| Function : static bool Check_Char(
1014| FIELDTYPE * typ,
1015| int ch,
1016| TypeArgument *argp)
1017|
1018| Description : Perform a single character check for character ch
1019| according to the fieldtype instance.
1020|
1021| Return Values : TRUE - Character is valid
1022| FALSE - Character is invalid
1023+--------------------------------------------------------------------------*/
1024static bool
1025Check_Char(FIELDTYPE *typ, int ch, TypeArgument *argp)
1026{
1027 if (typ)
1028 {
1029 if (typ->status & _LINKED_TYPE)
1030 {
1031 assert(argp);
1032 return (
1033 Check_Char(typ->left, ch, argp->left) ||
1034 Check_Char(typ->right, ch, argp->right));
1035 }
1036 else
1037 {
1038 if (typ->ccheck)
1039 return typ->ccheck(ch, (void *)argp);
1040 }
1041 }
1042 return (!iscntrl(UChar(ch)) ? TRUE : FALSE);
1043}
1044
1045/*---------------------------------------------------------------------------
1046| Facility : libnform
1047| Function : static int Display_Or_Erase_Field(
1048| FIELD * field,
1049| bool bEraseFlag)
1050|
1051| Description : Create a subwindow for the field and display the
1052| buffer contents (apply justification if required)
1053| or simply erase the field.
1054|
1055| Return Values : E_OK - on success
1056| E_SYSTEM_ERROR - some error (typical no memory)
1057+--------------------------------------------------------------------------*/
1058static int
1059Display_Or_Erase_Field(FIELD *field, bool bEraseFlag)
1060{
1061 WINDOW *win;
1062 WINDOW *fwin;
1063
1064 if (!field)
1065 return E_SYSTEM_ERROR;
1066
1067 fwin = Get_Form_Window(field->form);
1068 win = derwin(fwin,
1069 field->rows, field->cols, field->frow, field->fcol);
1070
1071 if (!win)
1072 return E_SYSTEM_ERROR;
1073 else
1074 {
1075 if (field->opts & O_VISIBLE)
1076 Set_Field_Window_Attributes(field, win);
1077 else
1078 wattrset(win, WINDOW_ATTRS(fwin));
1079 werase(win);
1080 }
1081
1082 if (!bEraseFlag)
1083 {
1084 if (field->opts & O_PUBLIC)
1085 {
1086 if (Justification_Allowed(field))
1087 Perform_Justification(field, win);
1088 else
1089 Buffer_To_Window(field, win);
1090 }
1091 field->status &= ~_NEWTOP;
1092 }
1093 wsyncup(win);
1094 delwin(win);
1095 return E_OK;
1096}
1097
1098/* Macros to preset the bEraseFlag */
1099#define Display_Field(field) Display_Or_Erase_Field(field,FALSE)
1100#define Erase_Field(field) Display_Or_Erase_Field(field,TRUE)
1101
1102/*---------------------------------------------------------------------------
1103| Facility : libnform
1104| Function : static int Synchronize_Field(FIELD * field)
1105|
1106| Description : Synchronize the windows content with the value in
1107| the buffer.
1108|
1109| Return Values : E_OK - success
1110| E_BAD_ARGUMENT - invalid field pointer
1111| E_SYSTEM_ERROR - some severe basic error
1112+--------------------------------------------------------------------------*/
1113static int
1114Synchronize_Field(FIELD *field)
1115{
1116 FORM *form;
1117 int res = E_OK;
1118
1119 if (!field)
1120 return (E_BAD_ARGUMENT);
1121
1122 if (((form = field->form) != (FORM *)0)
1123 && Field_Really_Appears(field))
1124 {
1125 if (field == form->current)
1126 {
1127 form->currow = form->curcol = form->toprow = form->begincol = 0;
1128 werase(form->w);
1129
1130 if ((field->opts & O_PUBLIC) && Justification_Allowed(field))
1131 Undo_Justification(field, form->w);
1132 else
1133 Buffer_To_Window(field, form->w);
1134
1135 field->status |= _NEWTOP;
1136 res = _nc_Refresh_Current_Field(form);
1137 }
1138 else
1139 res = Display_Field(field);
1140 }
1141 field->status |= _CHANGED;
1142 return (res);
1143}
1144
1145/*---------------------------------------------------------------------------
1146| Facility : libnform
1147| Function : static int Synchronize_Linked_Fields(FIELD * field)
1148|
1149| Description : Propagate the Synchronize_Field function to all linked
1150| fields. The first error that occurs in the sequence
1151| of updates is the return value.
1152|
1153| Return Values : E_OK - success
1154| E_BAD_ARGUMENT - invalid field pointer
1155| E_SYSTEM_ERROR - some severe basic error
1156+--------------------------------------------------------------------------*/
1157static int
1158Synchronize_Linked_Fields(FIELD *field)
1159{
1160 FIELD *linked_field;
1161 int res = E_OK;
1162 int syncres;
1163
1164 if (!field)
1165 return (E_BAD_ARGUMENT);
1166
1167 if (!field->link)
1168 return (E_SYSTEM_ERROR);
1169
1170 for (linked_field = field->link;
1171 linked_field != field;
1172 linked_field = linked_field->link)
1173 {
1174 if (((syncres = Synchronize_Field(linked_field)) != E_OK) &&
1175 (res == E_OK))
1176 res = syncres;
1177 }
1178 return (res);
1179}
1180
1181/*---------------------------------------------------------------------------
1182| Facility : libnform
1183| Function : int _nc_Synchronize_Attributes(FIELD * field)
1184|
1185| Description : If a fields visual attributes have changed, this
1186| routine is called to propagate those changes to the
1187| screen.
1188|
1189| Return Values : E_OK - success
1190| E_BAD_ARGUMENT - invalid field pointer
1191| E_SYSTEM_ERROR - some severe basic error
1192+--------------------------------------------------------------------------*/
1193NCURSES_EXPORT(int)
1194_nc_Synchronize_Attributes(FIELD *field)
1195{
1196 FORM *form;
1197 int res = E_OK;
1198 WINDOW *formwin;
1199
1200 T((T_CALLED("_nc_Synchronize_Attributes(%p)"), field));
1201
1202 if (!field)
1203 returnCode(E_BAD_ARGUMENT);
1204
1205 CHECKPOS(field->form);
1206 if (((form = field->form) != (FORM *)0)
1207 && Field_Really_Appears(field))
1208 {
1209 if (form->current == field)
1210 {
1211 Synchronize_Buffer(form);
1212 Set_Field_Window_Attributes(field, form->w);
1213 werase(form->w);
1214 wmove(form->w, form->currow, form->curcol);
1215
1216 if (field->opts & O_PUBLIC)
1217 {
1218 if (Justification_Allowed(field))
1219 Undo_Justification(field, form->w);
1220 else
1221 Buffer_To_Window(field, form->w);
1222 }
1223 else
1224 {
1225 formwin = Get_Form_Window(form);
1226 copywin(form->w, formwin,
1227 0, 0,
1228 field->frow, field->fcol,
1229 field->rows - 1, field->cols - 1, 0);
1230 wsyncup(formwin);
1231 Buffer_To_Window(field, form->w);
1232 field->status |= _NEWTOP; /* fake refresh to paint all */
1233 _nc_Refresh_Current_Field(form);
1234 }
1235 }
1236 else
1237 {
1238 res = Display_Field(field);
1239 }
1240 }
1241 CHECKPOS(form);
1242 returnCode(res);
1243}
1244
1245/*---------------------------------------------------------------------------
1246| Facility : libnform
1247| Function : int _nc_Synchronize_Options(FIELD * field,
1248| Field_Options newopts)
1249|
1250| Description : If a fields options have changed, this routine is
1251| called to propagate these changes to the screen and
1252| to really change the behavior of the field.
1253|
1254| Return Values : E_OK - success
1255| E_BAD_ARGUMENT - invalid field pointer
1256| E_CURRENT - field is the current one
1257| E_SYSTEM_ERROR - some severe basic error
1258+--------------------------------------------------------------------------*/
1259NCURSES_EXPORT(int)
1260_nc_Synchronize_Options(FIELD *field, Field_Options newopts)
1261{
1262 Field_Options oldopts;
1263 Field_Options changed_opts;
1264 FORM *form;
1265 int res = E_OK;
1266
1267 T((T_CALLED("_nc_Synchronize_Options(%p,%#x)"), field, newopts));
1268
1269 if (!field)
1270 returnCode(E_BAD_ARGUMENT);
1271
1272 oldopts = field->opts;
1273 changed_opts = oldopts ^ newopts;
1274 field->opts = newopts;
1275 form = field->form;
1276
1277 if (form)
1278 {
1279 if (form->current == field)
1280 {
1281 field->opts = oldopts;
1282 returnCode(E_CURRENT);
1283 }
1284
1285 if (form->status & _POSTED)
1286 {
1287 if ((form->curpage == field->page))
1288 {
1289 if (changed_opts & O_VISIBLE)
1290 {
1291 if (newopts & O_VISIBLE)
1292 res = Display_Field(field);
1293 else
1294 res = Erase_Field(field);
1295 }
1296 else
1297 {
1298 if ((changed_opts & O_PUBLIC) &&
1299 (newopts & O_VISIBLE))
1300 res = Display_Field(field);
1301 }
1302 }
1303 }
1304 }
1305
1306 if (changed_opts & O_STATIC)
1307 {
1308 bool single_line_field = Single_Line_Field(field);
1309 int res2 = E_OK;
1310
1311 if (newopts & O_STATIC)
1312 {
1313 /* the field becomes now static */
1314 field->status &= ~_MAY_GROW;
1315 /* if actually we have no hidden columns, justification may
1316 occur again */
1317 if (single_line_field &&
1318 (field->cols == field->dcols) &&
1319 (field->just != NO_JUSTIFICATION) &&
1320 Field_Really_Appears(field))
1321 {
1322 res2 = Display_Field(field);
1323 }
1324 }
1325 else
1326 {
1327 /* field is no longer static */
1328 if ((field->maxgrow == 0) ||
1329 (single_line_field && (field->dcols < field->maxgrow)) ||
1330 (!single_line_field && (field->drows < field->maxgrow)))
1331 {
1332 field->status |= _MAY_GROW;
1333 /* a field with justification now changes its behavior,
1334 so we must redisplay it */
1335 if (single_line_field &&
1336 (field->just != NO_JUSTIFICATION) &&
1337 Field_Really_Appears(field))
1338 {
1339 res2 = Display_Field(field);
1340 }
1341 }
1342 }
1343 if (res2 != E_OK)
1344 res = res2;
1345 }
1346
1347 returnCode(res);
1348}
1349
1350/*---------------------------------------------------------------------------
1351| Facility : libnform
1352| Function : int _nc_Set_Current_Field(FORM * form,
1353| FIELD * newfield)
1354|
1355| Description : Make the newfield the new current field.
1356|
1357| Return Values : E_OK - success
1358| E_BAD_ARGUMENT - invalid form or field pointer
1359| E_SYSTEM_ERROR - some severe basic error
1360| E_NOT_CONNECTED - no fields are connected to the form
1361+--------------------------------------------------------------------------*/
1362NCURSES_EXPORT(int)
1363_nc_Set_Current_Field(FORM *form, FIELD *newfield)
1364{
1365 FIELD *field;
1366 WINDOW *new_window;
1367
1368 T((T_CALLED("_nc_Set_Current_Field(%p,%p)"), form, newfield));
1369
1370 if (!form || !newfield || !form->current || (newfield->form != form))
1371 returnCode(E_BAD_ARGUMENT);
1372
1373 if ((form->status & _IN_DRIVER))
1374 returnCode(E_BAD_STATE);
1375
1376 if (!(form->field))
1377 returnCode(E_NOT_CONNECTED);
1378
1379 field = form->current;
1380
1381 if ((field != newfield) ||
1382 !(form->status & _POSTED))
1383 {
1384 if ((form->w) &&
1385 (field->opts & O_VISIBLE) &&
1386 (field->form->curpage == field->page))
1387 {
1388 _nc_Refresh_Current_Field(form);
1389 if (field->opts & O_PUBLIC)
1390 {
1391 if (field->drows > field->rows)
1392 {
1393 if (form->toprow == 0)
1394 field->status &= ~_NEWTOP;
1395 else
1396 field->status |= _NEWTOP;
1397 }
1398 else
1399 {
1400 if (Justification_Allowed(field))
1401 {
1402 Window_To_Buffer(form->w, field);
1403 werase(form->w);
1404 Perform_Justification(field, form->w);
1405 wsyncup(form->w);
1406 }
1407 }
1408 }
1409 delwin(form->w);
1410 form->w = (WINDOW *)0;
1411 }
1412
1413 field = newfield;
1414
1415 if (Has_Invisible_Parts(field))
1416 new_window = newpad(field->drows, field->dcols);
1417 else
1418 new_window = derwin(Get_Form_Window(form),
1419 field->rows, field->cols, field->frow, field->fcol);
1420
1421 if (!new_window)
1422 returnCode(E_SYSTEM_ERROR);
1423
1424 form->current = field;
1425
1426 if (form->w)
1427 delwin(form->w);
1428 form->w = new_window;
1429
1430 form->status &= ~_WINDOW_MODIFIED;
1431 Set_Field_Window_Attributes(field, form->w);
1432
1433 if (Has_Invisible_Parts(field))
1434 {
1435 werase(form->w);
1436 Buffer_To_Window(field, form->w);
1437 }
1438 else
1439 {
1440 if (Justification_Allowed(field))
1441 {
1442 werase(form->w);
1443 Undo_Justification(field, form->w);
1444 wsyncup(form->w);
1445 }
1446 }
1447
1448 untouchwin(form->w);
1449 }
1450
1451 form->currow = form->curcol = form->toprow = form->begincol = 0;
1452 returnCode(E_OK);
1453}
1454
1455/*----------------------------------------------------------------------------
1456 Intra-Field Navigation routines
1457 --------------------------------------------------------------------------*/
1458
1459/*---------------------------------------------------------------------------
1460| Facility : libnform
1461| Function : static int IFN_Next_Character(FORM * form)
1462|
1463| Description : Move to the next character in the field. In a multi-line
1464| field this wraps at the end of the line.
1465|
1466| Return Values : E_OK - success
1467| E_REQUEST_DENIED - at the rightmost position
1468+--------------------------------------------------------------------------*/
1469static int
1470IFN_Next_Character(FORM *form)
1471{
1472 FIELD *field = form->current;
1473 int step = myWCWIDTH(form->w, form->currow, form->curcol);
1474
1475 T((T_CALLED("IFN_Next_Character(%p)"), form));
1476 if ((form->curcol += step) == field->dcols)
1477 {
1478 if ((++(form->currow)) == field->drows)
1479 {
1480#if GROW_IF_NAVIGATE
1481 if (!Single_Line_Field(field) && Field_Grown(field, 1))
1482 {
1483 form->curcol = 0;
1484 returnCode(E_OK);
1485 }
1486#endif
1487 form->currow--;
1488#if GROW_IF_NAVIGATE
1489 if (Single_Line_Field(field) && Field_Grown(field, 1))
1490 returnCode(E_OK);
1491#endif
1492 form->curcol -= step;
1493 returnCode(E_REQUEST_DENIED);
1494 }
1495 form->curcol = 0;
1496 }
1497 returnCode(E_OK);
1498}
1499
1500/*---------------------------------------------------------------------------
1501| Facility : libnform
1502| Function : static int IFN_Previous_Character(FORM * form)
1503|
1504| Description : Move to the previous character in the field. In a
1505| multi-line field this wraps and the beginning of the
1506| line.
1507|
1508| Return Values : E_OK - success
1509| E_REQUEST_DENIED - at the leftmost position
1510+--------------------------------------------------------------------------*/
1511static int
1512IFN_Previous_Character(FORM *form)
1513{
1514 int amount = myWCWIDTH(form->w, form->currow, form->curcol - 1);
1515 int oldcol = form->curcol;
1516
1517 T((T_CALLED("IFN_Previous_Character(%p)"), form));
1518 if ((form->curcol -= amount) < 0)
1519 {
1520 if ((--(form->currow)) < 0)
1521 {
1522 form->currow++;
1523 form->curcol = oldcol;
1524 returnCode(E_REQUEST_DENIED);
1525 }
1526 form->curcol = form->current->dcols - 1;
1527 }
1528 returnCode(E_OK);
1529}
1530
1531/*---------------------------------------------------------------------------
1532| Facility : libnform
1533| Function : static int IFN_Next_Line(FORM * form)
1534|
1535| Description : Move to the beginning of the next line in the field
1536|
1537| Return Values : E_OK - success
1538| E_REQUEST_DENIED - at the last line
1539+--------------------------------------------------------------------------*/
1540static int
1541IFN_Next_Line(FORM *form)
1542{
1543 FIELD *field = form->current;
1544
1545 T((T_CALLED("IFN_Next_Line(%p)"), form));
1546 if ((++(form->currow)) == field->drows)
1547 {
1548#if GROW_IF_NAVIGATE
1549 if (!Single_Line_Field(field) && Field_Grown(field, 1))
1550 returnCode(E_OK);
1551#endif
1552 form->currow--;
1553 returnCode(E_REQUEST_DENIED);
1554 }
1555 form->curcol = 0;
1556 returnCode(E_OK);
1557}
1558
1559/*---------------------------------------------------------------------------
1560| Facility : libnform
1561| Function : static int IFN_Previous_Line(FORM * form)
1562|
1563| Description : Move to the beginning of the previous line in the field
1564|
1565| Return Values : E_OK - success
1566| E_REQUEST_DENIED - at the first line
1567+--------------------------------------------------------------------------*/
1568static int
1569IFN_Previous_Line(FORM *form)
1570{
1571 T((T_CALLED("IFN_Previous_Line(%p)"), form));
1572 if ((--(form->currow)) < 0)
1573 {
1574 form->currow++;
1575 returnCode(E_REQUEST_DENIED);
1576 }
1577 form->curcol = 0;
1578 returnCode(E_OK);
1579}
1580
1581/*---------------------------------------------------------------------------
1582| Facility : libnform
1583| Function : static int IFN_Next_Word(FORM * form)
1584|
1585| Description : Move to the beginning of the next word in the field.
1586|
1587| Return Values : E_OK - success
1588| E_REQUEST_DENIED - there is no next word
1589+--------------------------------------------------------------------------*/
1590static int
1591IFN_Next_Word(FORM *form)
1592{
1593 FIELD *field = form->current;
1594 FIELD_CELL *bp = Address_Of_Current_Position_In_Buffer(form);
1595 FIELD_CELL *s;
1596 FIELD_CELL *t;
1597
1598 T((T_CALLED("IFN_Next_Word(%p)"), form));
1599
1600 /* We really need access to the data, so we have to synchronize */
1601 Synchronize_Buffer(form);
1602
1603 /* Go to the first whitespace after the current position (including
1604 current position). This is then the starting point to look for the
1605 next non-blank data */
1606 s = Get_First_Whitespace_Character(bp, Buffer_Length(field) -
1607 (int)(bp - field->buf));
1608
1609 /* Find the start of the next word */
1610 t = Get_Start_Of_Data(s, Buffer_Length(field) -
1611 (int)(s - field->buf));
1612#if !FRIENDLY_PREV_NEXT_WORD
1613 if (s == t)
1614 returnCode(E_REQUEST_DENIED);
1615 else
1616#endif
1617 {
1618 Adjust_Cursor_Position(form, t);
1619 returnCode(E_OK);
1620 }
1621}
1622
1623/*---------------------------------------------------------------------------
1624| Facility : libnform
1625| Function : static int IFN_Previous_Word(FORM * form)
1626|
1627| Description : Move to the beginning of the previous word in the field.
1628|
1629| Return Values : E_OK - success
1630| E_REQUEST_DENIED - there is no previous word
1631+--------------------------------------------------------------------------*/
1632static int
1633IFN_Previous_Word(FORM *form)
1634{
1635 FIELD *field = form->current;
1636 FIELD_CELL *bp = Address_Of_Current_Position_In_Buffer(form);
1637 FIELD_CELL *s;
1638 FIELD_CELL *t;
1639 bool again = FALSE;
1640
1641 T((T_CALLED("IFN_Previous_Word(%p)"), form));
1642
1643 /* We really need access to the data, so we have to synchronize */
1644 Synchronize_Buffer(form);
1645
1646 s = After_End_Of_Data(field->buf, (int)(bp - field->buf));
1647 /* s points now right after the last non-blank in the buffer before bp.
1648 If bp was in a word, s equals bp. In this case we must find the last
1649 whitespace in the buffer before bp and repeat the game to really find
1650 the previous word! */
1651 if (s == bp)
1652 again = TRUE;
1653
1654 /* And next call now goes backward to look for the last whitespace
1655 before that, pointing right after this, so it points to the begin
1656 of the previous word.
1657 */
1658 t = After_Last_Whitespace_Character(field->buf, (int)(s - field->buf));
1659#if !FRIENDLY_PREV_NEXT_WORD
1660 if (s == t)
1661 returnCode(E_REQUEST_DENIED);
1662#endif
1663 if (again)
1664 {
1665 /* and do it again, replacing bp by t */
1666 s = After_End_Of_Data(field->buf, (int)(t - field->buf));
1667 t = After_Last_Whitespace_Character(field->buf, (int)(s - field->buf));
1668#if !FRIENDLY_PREV_NEXT_WORD
1669 if (s == t)
1670 returnCode(E_REQUEST_DENIED);
1671#endif
1672 }
1673 Adjust_Cursor_Position(form, t);
1674 returnCode(E_OK);
1675}
1676
1677/*---------------------------------------------------------------------------
1678| Facility : libnform
1679| Function : static int IFN_Beginning_Of_Field(FORM * form)
1680|
1681| Description : Place the cursor at the first non-pad character in
1682| the field.
1683|
1684| Return Values : E_OK - success
1685+--------------------------------------------------------------------------*/
1686static int
1687IFN_Beginning_Of_Field(FORM *form)
1688{
1689 FIELD *field = form->current;
1690
1691 T((T_CALLED("IFN_Beginning_Of_Field(%p)"), form));
1692 Synchronize_Buffer(form);
1693 Adjust_Cursor_Position(form,
1694 Get_Start_Of_Data(field->buf, Buffer_Length(field)));
1695 returnCode(E_OK);
1696}
1697
1698/*---------------------------------------------------------------------------
1699| Facility : libnform
1700| Function : static int IFN_End_Of_Field(FORM * form)
1701|
1702| Description : Place the cursor after the last non-pad character in
1703| the field. If the field occupies the last position in
1704| the buffer, the cursor is positioned on the last
1705| character.
1706|
1707| Return Values : E_OK - success
1708+--------------------------------------------------------------------------*/
1709static int
1710IFN_End_Of_Field(FORM *form)
1711{
1712 FIELD *field = form->current;
1713 FIELD_CELL *pos;
1714
1715 T((T_CALLED("IFN_End_Of_Field(%p)"), form));
1716 Synchronize_Buffer(form);
1717 pos = After_End_Of_Data(field->buf, Buffer_Length(field));
1718 if (pos == (field->buf + Buffer_Length(field)))
1719 pos--;
1720 Adjust_Cursor_Position(form, pos);
1721 returnCode(E_OK);
1722}
1723
1724/*---------------------------------------------------------------------------
1725| Facility : libnform
1726| Function : static int IFN_Beginning_Of_Line(FORM * form)
1727|
1728| Description : Place the cursor on the first non-pad character in
1729| the current line of the field.
1730|
1731| Return Values : E_OK - success
1732+--------------------------------------------------------------------------*/
1733static int
1734IFN_Beginning_Of_Line(FORM *form)
1735{
1736 FIELD *field = form->current;
1737
1738 T((T_CALLED("IFN_Beginning_Of_Line(%p)"), form));
1739 Synchronize_Buffer(form);
1740 Adjust_Cursor_Position(form,
1741 Get_Start_Of_Data(Address_Of_Current_Row_In_Buffer(form),
1742 field->dcols));
1743 returnCode(E_OK);
1744}
1745
1746/*---------------------------------------------------------------------------
1747| Facility : libnform
1748| Function : static int IFN_End_Of_Line(FORM * form)
1749|
1750| Description : Place the cursor after the last non-pad character in the
1751| current line of the field. If the field occupies the
1752| last column in the line, the cursor is positioned on the
1753| last character of the line.
1754|
1755| Return Values : E_OK - success
1756+--------------------------------------------------------------------------*/
1757static int
1758IFN_End_Of_Line(FORM *form)
1759{
1760 FIELD *field = form->current;
1761 FIELD_CELL *pos;
1762 FIELD_CELL *bp;
1763
1764 T((T_CALLED("IFN_End_Of_Line(%p)"), form));
1765 Synchronize_Buffer(form);
1766 bp = Address_Of_Current_Row_In_Buffer(form);
1767 pos = After_End_Of_Data(bp, field->dcols);
1768 if (pos == (bp + field->dcols))
1769 pos--;
1770 Adjust_Cursor_Position(form, pos);
1771 returnCode(E_OK);
1772}
1773
1774/*---------------------------------------------------------------------------
1775| Facility : libnform
1776| Function : static int IFN_Left_Character(FORM * form)
1777|
1778| Description : Move one character to the left in the current line.
1779| This doesn't cycle.
1780|
1781| Return Values : E_OK - success
1782| E_REQUEST_DENIED - already in first column
1783+--------------------------------------------------------------------------*/
1784static int
1785IFN_Left_Character(FORM *form)
1786{
1787 int amount = myWCWIDTH(form->w, form->currow, form->curcol - 1);
1788 int oldcol = form->curcol;
1789
1790 T((T_CALLED("IFN_Left_Character(%p)"), form));
1791 if ((form->curcol -= amount) < 0)
1792 {
1793 form->curcol = oldcol;
1794 returnCode(E_REQUEST_DENIED);
1795 }
1796 returnCode(E_OK);
1797}
1798
1799/*---------------------------------------------------------------------------
1800| Facility : libnform
1801| Function : static int IFN_Right_Character(FORM * form)
1802|
1803| Description : Move one character to the right in the current line.
1804| This doesn't cycle.
1805|
1806| Return Values : E_OK - success
1807| E_REQUEST_DENIED - already in last column
1808+--------------------------------------------------------------------------*/
1809static int
1810IFN_Right_Character(FORM *form)
1811{
1812 int amount = myWCWIDTH(form->w, form->currow, form->curcol);
1813 int oldcol = form->curcol;
1814
1815 T((T_CALLED("IFN_Right_Character(%p)"), form));
1816 if ((form->curcol += amount) >= form->current->dcols)
1817 {
1818#if GROW_IF_NAVIGATE
1819 FIELD *field = form->current;
1820
1821 if (Single_Line_Field(field) && Field_Grown(field, 1))
1822 returnCode(E_OK);
1823#endif
1824 form->curcol = oldcol;
1825 returnCode(E_REQUEST_DENIED);
1826 }
1827 returnCode(E_OK);
1828}
1829
1830/*---------------------------------------------------------------------------
1831| Facility : libnform
1832| Function : static int IFN_Up_Character(FORM * form)
1833|
1834| Description : Move one line up. This doesn't cycle through the lines
1835| of the field.
1836|
1837| Return Values : E_OK - success
1838| E_REQUEST_DENIED - already in last column
1839+--------------------------------------------------------------------------*/
1840static int
1841IFN_Up_Character(FORM *form)
1842{
1843 T((T_CALLED("IFN_Up_Character(%p)"), form));
1844 if ((--(form->currow)) < 0)
1845 {
1846 form->currow++;
1847 returnCode(E_REQUEST_DENIED);
1848 }
1849 returnCode(E_OK);
1850}
1851
1852/*---------------------------------------------------------------------------
1853| Facility : libnform
1854| Function : static int IFN_Down_Character(FORM * form)
1855|
1856| Description : Move one line down. This doesn't cycle through the
1857| lines of the field.
1858|
1859| Return Values : E_OK - success
1860| E_REQUEST_DENIED - already in last column
1861+--------------------------------------------------------------------------*/
1862static int
1863IFN_Down_Character(FORM *form)
1864{
1865 FIELD *field = form->current;
1866
1867 T((T_CALLED("IFN_Down_Character(%p)"), form));
1868 if ((++(form->currow)) == field->drows)
1869 {
1870#if GROW_IF_NAVIGATE
1871 if (!Single_Line_Field(field) && Field_Grown(field, 1))
1872 returnCode(E_OK);
1873#endif
1874 --(form->currow);
1875 returnCode(E_REQUEST_DENIED);
1876 }
1877 returnCode(E_OK);
1878}
1879/*----------------------------------------------------------------------------
1880 END of Intra-Field Navigation routines
1881 --------------------------------------------------------------------------*/
1882
1883/*----------------------------------------------------------------------------
1884 Vertical scrolling helper routines
1885 --------------------------------------------------------------------------*/
1886
1887/*---------------------------------------------------------------------------
1888| Facility : libnform
1889| Function : static int VSC_Generic(FORM *form, int nlines)
1890|
1891| Description : Scroll multi-line field forward (nlines>0) or
1892| backward (nlines<0) this many lines.
1893|
1894| Return Values : E_OK - success
1895| E_REQUEST_DENIED - can't scroll
1896+--------------------------------------------------------------------------*/
1897static int
1898VSC_Generic(FORM *form, int nlines)
1899{
1900 FIELD *field = form->current;
1901 int res = E_REQUEST_DENIED;
1902 int rows_to_go = (nlines > 0 ? nlines : -nlines);
1903
1904 if (nlines > 0)
1905 {
1906 if ((rows_to_go + form->toprow) > (field->drows - field->rows))
1907 rows_to_go = (field->drows - field->rows - form->toprow);
1908
1909 if (rows_to_go > 0)
1910 {
1911 form->currow += rows_to_go;
1912 form->toprow += rows_to_go;
1913 res = E_OK;
1914 }
1915 }
1916 else
1917 {
1918 if (rows_to_go > form->toprow)
1919 rows_to_go = form->toprow;
1920
1921 if (rows_to_go > 0)
1922 {
1923 form->currow -= rows_to_go;
1924 form->toprow -= rows_to_go;
1925 res = E_OK;
1926 }
1927 }
1928 return (res);
1929}
1930/*----------------------------------------------------------------------------
1931 End of Vertical scrolling helper routines
1932 --------------------------------------------------------------------------*/
1933
1934/*----------------------------------------------------------------------------
1935 Vertical scrolling routines
1936 --------------------------------------------------------------------------*/
1937
1938/*---------------------------------------------------------------------------
1939| Facility : libnform
1940| Function : static int Vertical_Scrolling(
1941| int (* const fct) (FORM *),
1942| FORM * form)
1943|
1944| Description : Performs the generic vertical scrolling routines.
1945| This has to check for a multi-line field and to set
1946| the _NEWTOP flag if scrolling really occurred.
1947|
1948| Return Values : Propagated error code from low-level driver calls
1949+--------------------------------------------------------------------------*/
1950static int
1951Vertical_Scrolling(int (*const fct) (FORM *), FORM *form)
1952{
1953 int res = E_REQUEST_DENIED;
1954
1955 if (!Single_Line_Field(form->current))
1956 {
1957 res = fct(form);
1958 if (res == E_OK)
1959 form->current->status |= _NEWTOP;
1960 }
1961 return (res);
1962}
1963
1964/*---------------------------------------------------------------------------
1965| Facility : libnform
1966| Function : static int VSC_Scroll_Line_Forward(FORM * form)
1967|
1968| Description : Scroll multi-line field forward a line
1969|
1970| Return Values : E_OK - success
1971| E_REQUEST_DENIED - no data ahead
1972+--------------------------------------------------------------------------*/
1973static int
1974VSC_Scroll_Line_Forward(FORM *form)
1975{
1976 T((T_CALLED("VSC_Scroll_Line_Forward(%p)"), form));
1977 returnCode(VSC_Generic(form, 1));
1978}
1979
1980/*---------------------------------------------------------------------------
1981| Facility : libnform
1982| Function : static int VSC_Scroll_Line_Backward(FORM * form)
1983|
1984| Description : Scroll multi-line field backward a line
1985|
1986| Return Values : E_OK - success
1987| E_REQUEST_DENIED - no data behind
1988+--------------------------------------------------------------------------*/
1989static int
1990VSC_Scroll_Line_Backward(FORM *form)
1991{
1992 T((T_CALLED("VSC_Scroll_Line_Backward(%p)"), form));
1993 returnCode(VSC_Generic(form, -1));
1994}
1995
1996/*---------------------------------------------------------------------------
1997| Facility : libnform
1998| Function : static int VSC_Scroll_Page_Forward(FORM * form)
1999|
2000| Description : Scroll a multi-line field forward a page
2001|
2002| Return Values : E_OK - success
2003| E_REQUEST_DENIED - no data ahead
2004+--------------------------------------------------------------------------*/
2005static int
2006VSC_Scroll_Page_Forward(FORM *form)
2007{
2008 T((T_CALLED("VSC_Scroll_Page_Forward(%p)"), form));
2009 returnCode(VSC_Generic(form, form->current->rows));
2010}
2011
2012/*---------------------------------------------------------------------------
2013| Facility : libnform
2014| Function : static int VSC_Scroll_Half_Page_Forward(FORM * form)
2015|
2016| Description : Scroll a multi-line field forward half a page
2017|
2018| Return Values : E_OK - success
2019| E_REQUEST_DENIED - no data ahead
2020+--------------------------------------------------------------------------*/
2021static int
2022VSC_Scroll_Half_Page_Forward(FORM *form)
2023{
2024 T((T_CALLED("VSC_Scroll_Half_Page_Forward(%p)"), form));
2025 returnCode(VSC_Generic(form, (form->current->rows + 1) / 2));
2026}
2027
2028/*---------------------------------------------------------------------------
2029| Facility : libnform
2030| Function : static int VSC_Scroll_Page_Backward(FORM * form)
2031|
2032| Description : Scroll a multi-line field backward a page
2033|
2034| Return Values : E_OK - success
2035| E_REQUEST_DENIED - no data behind
2036+--------------------------------------------------------------------------*/
2037static int
2038VSC_Scroll_Page_Backward(FORM *form)
2039{
2040 T((T_CALLED("VSC_Scroll_Page_Backward(%p)"), form));
2041 returnCode(VSC_Generic(form, -(form->current->rows)));
2042}
2043
2044/*---------------------------------------------------------------------------
2045| Facility : libnform
2046| Function : static int VSC_Scroll_Half_Page_Backward(FORM * form)
2047|
2048| Description : Scroll a multi-line field backward half a page
2049|
2050| Return Values : E_OK - success
2051| E_REQUEST_DENIED - no data behind
2052+--------------------------------------------------------------------------*/
2053static int
2054VSC_Scroll_Half_Page_Backward(FORM *form)
2055{
2056 T((T_CALLED("VSC_Scroll_Half_Page_Backward(%p)"), form));
2057 returnCode(VSC_Generic(form, -((form->current->rows + 1) / 2)));
2058}
2059/*----------------------------------------------------------------------------
2060 End of Vertical scrolling routines
2061 --------------------------------------------------------------------------*/
2062
2063/*----------------------------------------------------------------------------
2064 Horizontal scrolling helper routines
2065 --------------------------------------------------------------------------*/
2066
2067/*---------------------------------------------------------------------------
2068| Facility : libnform
2069| Function : static int HSC_Generic(FORM *form, int ncolumns)
2070|
2071| Description : Scroll single-line field forward (ncolumns>0) or
2072| backward (ncolumns<0) this many columns.
2073|
2074| Return Values : E_OK - success
2075| E_REQUEST_DENIED - can't scroll
2076+--------------------------------------------------------------------------*/
2077static int
2078HSC_Generic(FORM *form, int ncolumns)
2079{
2080 FIELD *field = form->current;
2081 int res = E_REQUEST_DENIED;
2082 int cols_to_go = (ncolumns > 0 ? ncolumns : -ncolumns);
2083
2084 if (ncolumns > 0)
2085 {
2086 if ((cols_to_go + form->begincol) > (field->dcols - field->cols))
2087 cols_to_go = field->dcols - field->cols - form->begincol;
2088
2089 if (cols_to_go > 0)
2090 {
2091 form->curcol += cols_to_go;
2092 form->begincol += cols_to_go;
2093 res = E_OK;
2094 }
2095 }
2096 else
2097 {
2098 if (cols_to_go > form->begincol)
2099 cols_to_go = form->begincol;
2100
2101 if (cols_to_go > 0)
2102 {
2103 form->curcol -= cols_to_go;
2104 form->begincol -= cols_to_go;
2105 res = E_OK;
2106 }
2107 }
2108 return (res);
2109}
2110/*----------------------------------------------------------------------------
2111 End of Horizontal scrolling helper routines
2112 --------------------------------------------------------------------------*/
2113
2114/*----------------------------------------------------------------------------
2115 Horizontal scrolling routines
2116 --------------------------------------------------------------------------*/
2117
2118/*---------------------------------------------------------------------------
2119| Facility : libnform
2120| Function : static int Horizontal_Scrolling(
2121| int (* const fct) (FORM *),
2122| FORM * form)
2123|
2124| Description : Performs the generic horizontal scrolling routines.
2125| This has to check for a single-line field.
2126|
2127| Return Values : Propagated error code from low-level driver calls
2128+--------------------------------------------------------------------------*/
2129static int
2130Horizontal_Scrolling(int (*const fct) (FORM *), FORM *form)
2131{
2132 if (Single_Line_Field(form->current))
2133 return fct(form);
2134 else
2135 return (E_REQUEST_DENIED);
2136}
2137
2138/*---------------------------------------------------------------------------
2139| Facility : libnform
2140| Function : static int HSC_Scroll_Char_Forward(FORM * form)
2141|
2142| Description : Scroll single-line field forward a character
2143|
2144| Return Values : E_OK - success
2145| E_REQUEST_DENIED - no data ahead
2146+--------------------------------------------------------------------------*/
2147static int
2148HSC_Scroll_Char_Forward(FORM *form)
2149{
2150 T((T_CALLED("HSC_Scroll_Char_Forward(%p)"), form));
2151 returnCode(HSC_Generic(form, 1));
2152}
2153
2154/*---------------------------------------------------------------------------
2155| Facility : libnform
2156| Function : static int HSC_Scroll_Char_Backward(FORM * form)
2157|
2158| Description : Scroll single-line field backward a character
2159|
2160| Return Values : E_OK - success
2161| E_REQUEST_DENIED - no data behind
2162+--------------------------------------------------------------------------*/
2163static int
2164HSC_Scroll_Char_Backward(FORM *form)
2165{
2166 T((T_CALLED("HSC_Scroll_Char_Backward(%p)"), form));
2167 returnCode(HSC_Generic(form, -1));
2168}
2169
2170/*---------------------------------------------------------------------------
2171| Facility : libnform
2172| Function : static int HSC_Horizontal_Line_Forward(FORM* form)
2173|
2174| Description : Scroll single-line field forward a line
2175|
2176| Return Values : E_OK - success
2177| E_REQUEST_DENIED - no data ahead
2178+--------------------------------------------------------------------------*/
2179static int
2180HSC_Horizontal_Line_Forward(FORM *form)
2181{
2182 T((T_CALLED("HSC_Horizontal_Line_Forward(%p)"), form));
2183 returnCode(HSC_Generic(form, form->current->cols));
2184}
2185
2186/*---------------------------------------------------------------------------
2187| Facility : libnform
2188| Function : static int HSC_Horizontal_Half_Line_Forward(FORM* form)
2189|
2190| Description : Scroll single-line field forward half a line
2191|
2192| Return Values : E_OK - success
2193| E_REQUEST_DENIED - no data ahead
2194+--------------------------------------------------------------------------*/
2195static int
2196HSC_Horizontal_Half_Line_Forward(FORM *form)
2197{
2198 T((T_CALLED("HSC_Horizontal_Half_Line_Forward(%p)"), form));
2199 returnCode(HSC_Generic(form, (form->current->cols + 1) / 2));
2200}
2201
2202/*---------------------------------------------------------------------------
2203| Facility : libnform
2204| Function : static int HSC_Horizontal_Line_Backward(FORM* form)
2205|
2206| Description : Scroll single-line field backward a line
2207|
2208| Return Values : E_OK - success
2209| E_REQUEST_DENIED - no data behind
2210+--------------------------------------------------------------------------*/
2211static int
2212HSC_Horizontal_Line_Backward(FORM *form)
2213{
2214 T((T_CALLED("HSC_Horizontal_Line_Backward(%p)"), form));
2215 returnCode(HSC_Generic(form, -(form->current->cols)));
2216}
2217
2218/*---------------------------------------------------------------------------
2219| Facility : libnform
2220| Function : static int HSC_Horizontal_Half_Line_Backward(FORM* form)
2221|
2222| Description : Scroll single-line field backward half a line
2223|
2224| Return Values : E_OK - success
2225| E_REQUEST_DENIED - no data behind
2226+--------------------------------------------------------------------------*/
2227static int
2228HSC_Horizontal_Half_Line_Backward(FORM *form)
2229{
2230 T((T_CALLED("HSC_Horizontal_Half_Line_Backward(%p)"), form));
2231 returnCode(HSC_Generic(form, -((form->current->cols + 1) / 2)));
2232}
2233
2234/*----------------------------------------------------------------------------
2235 End of Horizontal scrolling routines
2236 --------------------------------------------------------------------------*/
2237
2238/*----------------------------------------------------------------------------
2239 Helper routines for Field Editing
2240 --------------------------------------------------------------------------*/
2241
2242/*---------------------------------------------------------------------------
2243| Facility : libnform
2244| Function : static bool Is_There_Room_For_A_Line(FORM * form)
2245|
2246| Description : Check whether or not there is enough room in the
2247| buffer to enter a whole line.
2248|
2249| Return Values : TRUE - there is enough space
2250| FALSE - there is not enough space
2251+--------------------------------------------------------------------------*/
2252NCURSES_INLINE static bool
2253Is_There_Room_For_A_Line(FORM *form)
2254{
2255 FIELD *field = form->current;
2256 FIELD_CELL *begin_of_last_line, *s;
2257
2258 Synchronize_Buffer(form);
2259 begin_of_last_line = Address_Of_Row_In_Buffer(field, (field->drows - 1));
2260 s = After_End_Of_Data(begin_of_last_line, field->dcols);
2261 return ((s == begin_of_last_line) ? TRUE : FALSE);
2262}
2263
2264/*---------------------------------------------------------------------------
2265| Facility : libnform
2266| Function : static bool Is_There_Room_For_A_Char_In_Line(FORM * form)
2267|
2268| Description : Checks whether or not there is room for a new character
2269| in the current line.
2270|
2271| Return Values : TRUE - there is room
2272| FALSE - there is not enough room (line full)
2273+--------------------------------------------------------------------------*/
2274NCURSES_INLINE static bool
2275Is_There_Room_For_A_Char_In_Line(FORM *form)
2276{
2277 int last_char_in_line;
2278
2279 wmove(form->w, form->currow, form->current->dcols - 1);
2280 last_char_in_line = (int)(winch(form->w) & A_CHARTEXT);
2281 wmove(form->w, form->currow, form->curcol);
2282 return (((last_char_in_line == form->current->pad) ||
2283 is_blank(last_char_in_line)) ? TRUE : FALSE);
2284}
2285
2286#define There_Is_No_Room_For_A_Char_In_Line(f) \
2287 !Is_There_Room_For_A_Char_In_Line(f)
2288
2289/*---------------------------------------------------------------------------
2290| Facility : libnform
2291| Function : static int Insert_String(
2292| FORM * form,
2293| int row,
2294| char *txt,
2295| int len )
2296|
2297| Description : Insert the 'len' characters beginning at pointer 'txt'
2298| into the 'row' of the 'form'. The insertion occurs
2299| on the beginning of the row, all other characters are
2300| moved to the right. After the text a pad character will
2301| be inserted to separate the text from the rest. If
2302| necessary the insertion moves characters on the next
2303| line to make place for the requested insertion string.
2304|
2305| Return Values : E_OK - success
2306| E_REQUEST_DENIED -
2307| E_SYSTEM_ERROR - system error
2308+--------------------------------------------------------------------------*/
2309static int
2310Insert_String(FORM *form, int row, FIELD_CELL *txt, int len)
2311{
2312 FIELD *field = form->current;
2313 FIELD_CELL *bp = Address_Of_Row_In_Buffer(field, row);
2314 int datalen = (int)(After_End_Of_Data(bp, field->dcols) - bp);
2315 int freelen = field->dcols - datalen;
2316 int requiredlen = len + 1;
2317 FIELD_CELL *split;
2318 int result = E_REQUEST_DENIED;
2319
2320 if (freelen >= requiredlen)
2321 {
2322 wmove(form->w, row, 0);
2323 myINSNSTR(form->w, txt, len);
2324 wmove(form->w, row, len);
2325 myINSNSTR(form->w, &myBLANK, 1);
2326 return E_OK;
2327 }
2328 else
2329 {
2330 /* we have to move characters on the next line. If we are on the
2331 last line this may work, if the field is growable */
2332 if ((row == (field->drows - 1)) && Growable(field))
2333 {
2334 if (!Field_Grown(field, 1))
2335 return (E_SYSTEM_ERROR);
2336 /* !!!Side-Effect : might be changed due to growth!!! */
2337 bp = Address_Of_Row_In_Buffer(field, row);
2338 }
2339
2340 if (row < (field->drows - 1))
2341 {
2342 split =
2343 After_Last_Whitespace_Character(bp,
2344 (int)(Get_Start_Of_Data(bp
2345 + field->dcols
2346 - requiredlen,
2347 requiredlen)
2348 - bp));
2349 /* split points now to the first character of the portion of the
2350 line that must be moved to the next line */
2351 datalen = (int)(split - bp); /* + freelen has to stay on this line */
2352 freelen = field->dcols - (datalen + freelen); /* for the next line */
2353
2354 if ((result = Insert_String(form, row + 1, split, freelen)) == E_OK)
2355 {
2356 wmove(form->w, row, datalen);
2357 wclrtoeol(form->w);
2358 wmove(form->w, row, 0);
2359 myINSNSTR(form->w, txt, len);
2360 wmove(form->w, row, len);
2361 myINSNSTR(form->w, &myBLANK, 1);
2362 return E_OK;
2363 }
2364 }
2365 return (result);
2366 }
2367}
2368
2369/*---------------------------------------------------------------------------
2370| Facility : libnform
2371| Function : static int Wrapping_Not_Necessary_Or_Wrapping_Ok(
2372| FORM * form)
2373|
2374| Description : If a character has been entered into a field, it may
2375| be that wrapping has to occur. This routine checks
2376| whether or not wrapping is required and if so, performs
2377| the wrapping.
2378|
2379| Return Values : E_OK - no wrapping required or wrapping
2380| was successful
2381| E_REQUEST_DENIED -
2382| E_SYSTEM_ERROR - some system error
2383+--------------------------------------------------------------------------*/
2384static int
2385Wrapping_Not_Necessary_Or_Wrapping_Ok(FORM *form)
2386{
2387 FIELD *field = form->current;
2388 int result = E_REQUEST_DENIED;
2389 bool Last_Row = ((field->drows - 1) == form->currow);
2390
2391 if ((field->opts & O_WRAP) && /* wrapping wanted */
2392 (!Single_Line_Field(field)) && /* must be multi-line */
2393 (There_Is_No_Room_For_A_Char_In_Line(form)) && /* line is full */
2394 (!Last_Row || Growable(field))) /* there are more lines */
2395 {
2396 FIELD_CELL *bp;
2397 FIELD_CELL *split;
2398 int chars_to_be_wrapped;
2399 int chars_to_remain_on_line;
2400
2401 if (Last_Row)
2402 {
2403 /* the above logic already ensures, that in this case the field
2404 is growable */
2405 if (!Field_Grown(field, 1))
2406 return E_SYSTEM_ERROR;
2407 }
2408 bp = Address_Of_Current_Row_In_Buffer(form);
2409 Window_To_Buffer(form->w, field);
2410 split = After_Last_Whitespace_Character(bp, field->dcols);
2411 /* split points to the first character of the sequence to be brought
2412 on the next line */
2413 chars_to_remain_on_line = (int)(split - bp);
2414 chars_to_be_wrapped = field->dcols - chars_to_remain_on_line;
2415 if (chars_to_remain_on_line > 0)
2416 {
2417 if ((result = Insert_String(form, form->currow + 1, split,
2418 chars_to_be_wrapped)) == E_OK)
2419 {
2420 wmove(form->w, form->currow, chars_to_remain_on_line);
2421 wclrtoeol(form->w);
2422 if (form->curcol >= chars_to_remain_on_line)
2423 {
2424 form->currow++;
2425 form->curcol -= chars_to_remain_on_line;
2426 }
2427 return E_OK;
2428 }
2429 }
2430 else
2431 return E_OK;
2432 if (result != E_OK)
2433 {
2434 DeleteChar(form);
2435 Window_To_Buffer(form->w, field);
2436 result = E_REQUEST_DENIED;
2437 }
2438 }
2439 else
2440 result = E_OK; /* wrapping was not necessary */
2441 return (result);
2442}
2443
2444/*----------------------------------------------------------------------------
2445 Field Editing routines
2446 --------------------------------------------------------------------------*/
2447
2448/*---------------------------------------------------------------------------
2449| Facility : libnform
2450| Function : static int Field_Editing(
2451| int (* const fct) (FORM *),
2452| FORM * form)
2453|
2454| Description : Generic routine for field editing requests. The driver
2455| routines are only called for editable fields, the
2456| _WINDOW_MODIFIED flag is set if editing occurred.
2457| This is somewhat special due to the overload semantics
2458| of the NEW_LINE and DEL_PREV requests.
2459|
2460| Return Values : Error code from low level drivers.
2461+--------------------------------------------------------------------------*/
2462static int
2463Field_Editing(int (*const fct) (FORM *), FORM *form)
2464{
2465 int res = E_REQUEST_DENIED;
2466
2467 /* We have to deal here with the specific case of the overloaded
2468 behavior of New_Line and Delete_Previous requests.
2469 They may end up in navigational requests if we are on the first
2470 character in a field. But navigation is also allowed on non-
2471 editable fields.
2472 */
2473 if ((fct == FE_Delete_Previous) &&
2474 (form->opts & O_BS_OVERLOAD) &&
2475 First_Position_In_Current_Field(form))
2476 {
2477 res = Inter_Field_Navigation(FN_Previous_Field, form);
2478 }
2479 else
2480 {
2481 if (fct == FE_New_Line)
2482 {
2483 if ((form->opts & O_NL_OVERLOAD) &&
2484 First_Position_In_Current_Field(form))
2485 {
2486 res = Inter_Field_Navigation(FN_Next_Field, form);
2487 }
2488 else
2489 /* FE_New_Line deals itself with the _WINDOW_MODIFIED flag */
2490 res = fct(form);
2491 }
2492 else
2493 {
2494 /* From now on, everything must be editable */
2495 if (form->current->opts & O_EDIT)
2496 {
2497 res = fct(form);
2498 if (res == E_OK)
2499 form->status |= _WINDOW_MODIFIED;
2500 }
2501 }
2502 }
2503 return res;
2504}
2505
2506/*---------------------------------------------------------------------------
2507| Facility : libnform
2508| Function : static int FE_New_Line(FORM * form)
2509|
2510| Description : Perform a new line request. This is rather complex
2511| compared to other routines in this code due to the
2512| rather difficult to understand description in the
2513| manuals.
2514|
2515| Return Values : E_OK - success
2516| E_REQUEST_DENIED - new line not allowed
2517| E_SYSTEM_ERROR - system error
2518+--------------------------------------------------------------------------*/
2519static int
2520FE_New_Line(FORM *form)
2521{
2522 FIELD *field = form->current;
2523 FIELD_CELL *bp, *t;
2524 bool Last_Row = ((field->drows - 1) == form->currow);
2525
2526 T((T_CALLED("FE_New_Line(%p)"), form));
2527 if (form->status & _OVLMODE)
2528 {
2529 if (Last_Row &&
2530 (!(Growable(field) && !Single_Line_Field(field))))
2531 {
2532 if (!(form->opts & O_NL_OVERLOAD))
2533 returnCode(E_REQUEST_DENIED);
2534 wmove(form->w, form->currow, form->curcol);
2535 wclrtoeol(form->w);
2536 /* we have to set this here, although it is also
2537 handled in the generic routine. The reason is,
2538 that FN_Next_Field may fail, but the form is
2539 definitively changed */
2540 form->status |= _WINDOW_MODIFIED;
2541 returnCode(Inter_Field_Navigation(FN_Next_Field, form));
2542 }
2543 else
2544 {
2545 if (Last_Row && !Field_Grown(field, 1))
2546 {
2547 /* N.B.: due to the logic in the 'if', LastRow==TRUE
2548 means here that the field is growable and not
2549 a single-line field */
2550 returnCode(E_SYSTEM_ERROR);
2551 }
2552 wmove(form->w, form->currow, form->curcol);
2553 wclrtoeol(form->w);
2554 form->currow++;
2555 form->curcol = 0;
2556 form->status |= _WINDOW_MODIFIED;
2557 returnCode(E_OK);
2558 }
2559 }
2560 else
2561 {
2562 /* Insert Mode */
2563 if (Last_Row &&
2564 !(Growable(field) && !Single_Line_Field(field)))
2565 {
2566 if (!(form->opts & O_NL_OVERLOAD))
2567 returnCode(E_REQUEST_DENIED);
2568 returnCode(Inter_Field_Navigation(FN_Next_Field, form));
2569 }
2570 else
2571 {
2572 bool May_Do_It = !Last_Row && Is_There_Room_For_A_Line(form);
2573
2574 if (!(May_Do_It || Growable(field)))
2575 returnCode(E_REQUEST_DENIED);
2576 if (!May_Do_It && !Field_Grown(field, 1))
2577 returnCode(E_SYSTEM_ERROR);
2578
2579 bp = Address_Of_Current_Position_In_Buffer(form);
2580 t = After_End_Of_Data(bp, field->dcols - form->curcol);
2581 wmove(form->w, form->currow, form->curcol);
2582 wclrtoeol(form->w);
2583 form->currow++;
2584 form->curcol = 0;
2585 wmove(form->w, form->currow, form->curcol);
2586 winsertln(form->w);
2587 myADDNSTR(form->w, bp, (int)(t - bp));
2588 form->status |= _WINDOW_MODIFIED;
2589 returnCode(E_OK);
2590 }
2591 }
2592}
2593
2594/*---------------------------------------------------------------------------
2595| Facility : libnform
2596| Function : static int FE_Insert_Character(FORM * form)
2597|
2598| Description : Insert blank character at the cursor position
2599|
2600| Return Values : E_OK
2601| E_REQUEST_DENIED
2602+--------------------------------------------------------------------------*/
2603static int
2604FE_Insert_Character(FORM *form)
2605{
2606 FIELD *field = form->current;
2607 int result = E_REQUEST_DENIED;
2608
2609 T((T_CALLED("FE_Insert_Character(%p)"), form));
2610 if (Check_Char(field->type, (int)C_BLANK, (TypeArgument *)(field->arg)))
2611 {
2612 bool There_Is_Room = Is_There_Room_For_A_Char_In_Line(form);
2613
2614 if (There_Is_Room ||
2615 ((Single_Line_Field(field) && Growable(field))))
2616 {
2617 if (!There_Is_Room && !Field_Grown(field, 1))
2618 result = E_SYSTEM_ERROR;
2619 else
2620 {
2621 winsch(form->w, (chtype)C_BLANK);
2622 result = Wrapping_Not_Necessary_Or_Wrapping_Ok(form);
2623 }
2624 }
2625 }
2626 returnCode(result);
2627}
2628
2629/*---------------------------------------------------------------------------
2630| Facility : libnform
2631| Function : static int FE_Insert_Line(FORM * form)
2632|
2633| Description : Insert a blank line at the cursor position
2634|
2635| Return Values : E_OK - success
2636| E_REQUEST_DENIED - line can not be inserted
2637+--------------------------------------------------------------------------*/
2638static int
2639FE_Insert_Line(FORM *form)
2640{
2641 FIELD *field = form->current;
2642 int result = E_REQUEST_DENIED;
2643
2644 T((T_CALLED("FE_Insert_Line(%p)"), form));
2645 if (Check_Char(field->type, (int)C_BLANK, (TypeArgument *)(field->arg)))
2646 {
2647 bool Maybe_Done = (form->currow != (field->drows - 1)) &&
2648 Is_There_Room_For_A_Line(form);
2649
2650 if (!Single_Line_Field(field) &&
2651 (Maybe_Done || Growable(field)))
2652 {
2653 if (!Maybe_Done && !Field_Grown(field, 1))
2654 result = E_SYSTEM_ERROR;
2655 else
2656 {
2657 form->curcol = 0;
2658 winsertln(form->w);
2659 result = E_OK;
2660 }
2661 }
2662 }
2663 returnCode(result);
2664}
2665
2666/*---------------------------------------------------------------------------
2667| Facility : libnform
2668| Function : static int FE_Delete_Character(FORM * form)
2669|
2670| Description : Delete character at the cursor position
2671|
2672| Return Values : E_OK - success
2673+--------------------------------------------------------------------------*/
2674static int
2675FE_Delete_Character(FORM *form)
2676{
2677 T((T_CALLED("FE_Delete_Character(%p)"), form));
2678 DeleteChar(form);
2679 returnCode(E_OK);
2680}
2681
2682/*---------------------------------------------------------------------------
2683| Facility : libnform
2684| Function : static int FE_Delete_Previous(FORM * form)
2685|
2686| Description : Delete character before cursor. Again this is a rather
2687| difficult piece compared to others due to the overloading
2688| semantics of backspace.
2689| N.B.: The case of overloaded BS on first field position
2690| is already handled in the generic routine.
2691|
2692| Return Values : E_OK - success
2693| E_REQUEST_DENIED - Character can't be deleted
2694+--------------------------------------------------------------------------*/
2695static int
2696FE_Delete_Previous(FORM *form)
2697{
2698 FIELD *field = form->current;
2699
2700 T((T_CALLED("FE_Delete_Previous(%p)"), form));
2701 if (First_Position_In_Current_Field(form))
2702 returnCode(E_REQUEST_DENIED);
2703
2704 if ((--(form->curcol)) < 0)
2705 {
2706 FIELD_CELL *this_line, *prev_line, *prev_end, *this_end;
2707 int this_row = form->currow;
2708
2709 form->curcol++;
2710 if (form->status & _OVLMODE)
2711 returnCode(E_REQUEST_DENIED);
2712
2713 prev_line = Address_Of_Row_In_Buffer(field, (form->currow - 1));
2714 this_line = Address_Of_Row_In_Buffer(field, (form->currow));
2715 Synchronize_Buffer(form);
2716 prev_end = After_End_Of_Data(prev_line, field->dcols);
2717 this_end = After_End_Of_Data(this_line, field->dcols);
2718 if ((int)(this_end - this_line) >
2719 (field->cols - (int)(prev_end - prev_line)))
2720 returnCode(E_REQUEST_DENIED);
2721 wmove(form->w, form->currow, form->curcol);
2722 wdeleteln(form->w);
2723 Adjust_Cursor_Position(form, prev_end);
2724 /*
2725 * If we did not really move to the previous line, help the user a
2726 * little. It is however a little inconsistent. Normally, when
2727 * backspacing around the point where text wraps to a new line in a
2728 * multi-line form, we absorb one keystroke for the wrapping point. That
2729 * is consistent with SVr4 forms. However, SVr4 does not allow typing
2730 * into the last column of the field, and requires the user to enter a
2731 * newline to move to the next line. Therefore it can consistently eat
2732 * that keystroke. Since ncurses allows the last column, it wraps
2733 * automatically (given the proper options). But we cannot eat the
2734 * keystroke to back over the wrapping point, since that would put the
2735 * cursor past the end of the form field. In this case, just delete the
2736 * character at the end of the field.
2737 */
2738 if (form->currow == this_row && this_row > 0)
2739 {
2740 form->currow -= 1;
2741 form->curcol = field->dcols - 1;
2742 DeleteChar(form);
2743 }
2744 else
2745 {
2746 wmove(form->w, form->currow, form->curcol);
2747 myADDNSTR(form->w, this_line, (int)(this_end - this_line));
2748 }
2749 }
2750 else
2751 {
2752 DeleteChar(form);
2753 }
2754 returnCode(E_OK);
2755}
2756
2757/*---------------------------------------------------------------------------
2758| Facility : libnform
2759| Function : static int FE_Delete_Line(FORM * form)
2760|
2761| Description : Delete line at cursor position.
2762|
2763| Return Values : E_OK - success
2764+--------------------------------------------------------------------------*/
2765static int
2766FE_Delete_Line(FORM *form)
2767{
2768 T((T_CALLED("FE_Delete_Line(%p)"), form));
2769 form->curcol = 0;
2770 wdeleteln(form->w);
2771 returnCode(E_OK);
2772}
2773
2774/*---------------------------------------------------------------------------
2775| Facility : libnform
2776| Function : static int FE_Delete_Word(FORM * form)
2777|
2778| Description : Delete word at cursor position
2779|
2780| Return Values : E_OK - success
2781| E_REQUEST_DENIED - failure
2782+--------------------------------------------------------------------------*/
2783static int
2784FE_Delete_Word(FORM *form)
2785{
2786 FIELD *field = form->current;
2787 FIELD_CELL *bp = Address_Of_Current_Row_In_Buffer(form);
2788 FIELD_CELL *ep = bp + field->dcols;
2789 FIELD_CELL *cp = bp + form->curcol;
2790 FIELD_CELL *s;
2791
2792 T((T_CALLED("FE_Delete_Word(%p)"), form));
2793 Synchronize_Buffer(form);
2794 if (ISBLANK(*cp))
2795 returnCode(E_REQUEST_DENIED); /* not in word */
2796
2797 /* move cursor to begin of word and erase to end of screen-line */
2798 Adjust_Cursor_Position(form,
2799 After_Last_Whitespace_Character(bp, form->curcol));
2800 wmove(form->w, form->currow, form->curcol);
2801 wclrtoeol(form->w);
2802
2803 /* skip over word in buffer */
2804 s = Get_First_Whitespace_Character(cp, (int)(ep - cp));
2805 /* to begin of next word */
2806 s = Get_Start_Of_Data(s, (int)(ep - s));
2807 if ((s != cp) && !ISBLANK(*s))
2808 {
2809 /* copy remaining line to window */
2810 myADDNSTR(form->w, s, (int)(s - After_End_Of_Data(s, (int)(ep - s))));
2811 }
2812 returnCode(E_OK);
2813}
2814
2815/*---------------------------------------------------------------------------
2816| Facility : libnform
2817| Function : static int FE_Clear_To_End_Of_Line(FORM * form)
2818|
2819| Description : Clear to end of current line.
2820|
2821| Return Values : E_OK - success
2822+--------------------------------------------------------------------------*/
2823static int
2824FE_Clear_To_End_Of_Line(FORM *form)
2825{
2826 T((T_CALLED("FE_Clear_To_End_Of_Line(%p)"), form));
2827 wmove(form->w, form->currow, form->curcol);
2828 wclrtoeol(form->w);
2829 returnCode(E_OK);
2830}
2831
2832/*---------------------------------------------------------------------------
2833| Facility : libnform
2834| Function : static int FE_Clear_To_End_Of_Field(FORM * form)
2835|
2836| Description : Clear to end of field.
2837|
2838| Return Values : E_OK - success
2839+--------------------------------------------------------------------------*/
2840static int
2841FE_Clear_To_End_Of_Field(FORM *form)
2842{
2843 T((T_CALLED("FE_Clear_To_End_Of_Field(%p)"), form));
2844 wmove(form->w, form->currow, form->curcol);
2845 wclrtobot(form->w);
2846 returnCode(E_OK);
2847}
2848
2849/*---------------------------------------------------------------------------
2850| Facility : libnform
2851| Function : static int FE_Clear_Field(FORM * form)
2852|
2853| Description : Clear entire field.
2854|
2855| Return Values : E_OK - success
2856+--------------------------------------------------------------------------*/
2857static int
2858FE_Clear_Field(FORM *form)
2859{
2860 T((T_CALLED("FE_Clear_Field(%p)"), form));
2861 form->currow = form->curcol = 0;
2862 werase(form->w);
2863 returnCode(E_OK);
2864}
2865/*----------------------------------------------------------------------------
2866 END of Field Editing routines
2867 --------------------------------------------------------------------------*/
2868
2869/*----------------------------------------------------------------------------
2870 Edit Mode routines
2871 --------------------------------------------------------------------------*/
2872
2873/*---------------------------------------------------------------------------
2874| Facility : libnform
2875| Function : static int EM_Overlay_Mode(FORM * form)
2876|
2877| Description : Switch to overlay mode.
2878|
2879| Return Values : E_OK - success
2880+--------------------------------------------------------------------------*/
2881static int
2882EM_Overlay_Mode(FORM *form)
2883{
2884 T((T_CALLED("EM_Overlay_Mode(%p)"), form));
2885 form->status |= _OVLMODE;
2886 returnCode(E_OK);
2887}
2888
2889/*---------------------------------------------------------------------------
2890| Facility : libnform
2891| Function : static int EM_Insert_Mode(FORM * form)
2892|
2893| Description : Switch to insert mode
2894|
2895| Return Values : E_OK - success
2896+--------------------------------------------------------------------------*/
2897static int
2898EM_Insert_Mode(FORM *form)
2899{
2900 T((T_CALLED("EM_Insert_Mode(%p)"), form));
2901 form->status &= ~_OVLMODE;
2902 returnCode(E_OK);
2903}
2904
2905/*----------------------------------------------------------------------------
2906 END of Edit Mode routines
2907 --------------------------------------------------------------------------*/
2908
2909/*----------------------------------------------------------------------------
2910 Helper routines for Choice Requests
2911 --------------------------------------------------------------------------*/
2912
2913/*---------------------------------------------------------------------------
2914| Facility : libnform
2915| Function : static bool Next_Choice(
2916| FIELDTYPE * typ,
2917| FIELD * field,
2918| TypeArgument *argp)
2919|
2920| Description : Get the next field choice. For linked types this is
2921| done recursively.
2922|
2923| Return Values : TRUE - next choice successfully retrieved
2924| FALSE - couldn't retrieve next choice
2925+--------------------------------------------------------------------------*/
2926static bool
2927Next_Choice(FIELDTYPE *typ, FIELD *field, TypeArgument *argp)
2928{
2929 if (!typ || !(typ->status & _HAS_CHOICE))
2930 return FALSE;
2931
2932 if (typ->status & _LINKED_TYPE)
2933 {
2934 assert(argp);
2935 return (
2936 Next_Choice(typ->left, field, argp->left) ||
2937 Next_Choice(typ->right, field, argp->right));
2938 }
2939 else
2940 {
2941 assert(typ->next);
2942 return typ->next(field, (void *)argp);
2943 }
2944}
2945
2946/*---------------------------------------------------------------------------
2947| Facility : libnform
2948| Function : static bool Previous_Choice(
2949| FIELDTYPE * typ,
2950| FIELD * field,
2951| TypeArgument *argp)
2952|
2953| Description : Get the previous field choice. For linked types this
2954| is done recursively.
2955|
2956| Return Values : TRUE - previous choice successfully retrieved
2957| FALSE - couldn't retrieve previous choice
2958+--------------------------------------------------------------------------*/
2959static bool
2960Previous_Choice(FIELDTYPE *typ, FIELD *field, TypeArgument *argp)
2961{
2962 if (!typ || !(typ->status & _HAS_CHOICE))
2963 return FALSE;
2964
2965 if (typ->status & _LINKED_TYPE)
2966 {
2967 assert(argp);
2968 return (
2969 Previous_Choice(typ->left, field, argp->left) ||
2970 Previous_Choice(typ->right, field, argp->right));
2971 }
2972 else
2973 {
2974 assert(typ->prev);
2975 return typ->prev(field, (void *)argp);
2976 }
2977}
2978/*----------------------------------------------------------------------------
2979 End of Helper routines for Choice Requests
2980 --------------------------------------------------------------------------*/
2981
2982/*----------------------------------------------------------------------------
2983 Routines for Choice Requests
2984 --------------------------------------------------------------------------*/
2985
2986/*---------------------------------------------------------------------------
2987| Facility : libnform
2988| Function : static int CR_Next_Choice(FORM * form)
2989|
2990| Description : Get the next field choice.
2991|
2992| Return Values : E_OK - success
2993| E_REQUEST_DENIED - next choice couldn't be retrieved
2994+--------------------------------------------------------------------------*/
2995static int
2996CR_Next_Choice(FORM *form)
2997{
2998 FIELD *field = form->current;
2999
3000 T((T_CALLED("CR_Next_Choice(%p)"), form));
3001 Synchronize_Buffer(form);
3002 returnCode((Next_Choice(field->type, field, (TypeArgument *)(field->arg)))
3003 ? E_OK
3004 : E_REQUEST_DENIED);
3005}
3006
3007/*---------------------------------------------------------------------------
3008| Facility : libnform
3009| Function : static int CR_Previous_Choice(FORM * form)
3010|
3011| Description : Get the previous field choice.
3012|
3013| Return Values : E_OK - success
3014| E_REQUEST_DENIED - prev. choice couldn't be retrieved
3015+--------------------------------------------------------------------------*/
3016static int
3017CR_Previous_Choice(FORM *form)
3018{
3019 FIELD *field = form->current;
3020
3021 T((T_CALLED("CR_Previous_Choice(%p)"), form));
3022 Synchronize_Buffer(form);
3023 returnCode((Previous_Choice(field->type, field, (TypeArgument *)(field->arg)))
3024 ? E_OK
3025 : E_REQUEST_DENIED);
3026}
3027/*----------------------------------------------------------------------------
3028 End of Routines for Choice Requests
3029 --------------------------------------------------------------------------*/
3030
3031/*----------------------------------------------------------------------------
3032 Helper routines for Field Validations.
3033 --------------------------------------------------------------------------*/
3034
3035/*---------------------------------------------------------------------------
3036| Facility : libnform
3037| Function : static bool Check_Field(
3038| FIELDTYPE * typ,
3039| FIELD * field,
3040| TypeArgument * argp)
3041|
3042| Description : Check the field according to its fieldtype and its
3043| actual arguments. For linked fieldtypes this is done
3044| recursively.
3045|
3046| Return Values : TRUE - field is valid
3047| FALSE - field is invalid.
3048+--------------------------------------------------------------------------*/
3049static bool
3050Check_Field(FIELDTYPE *typ, FIELD *field, TypeArgument *argp)
3051{
3052 if (typ)
3053 {
3054 if (field->opts & O_NULLOK)
3055 {
3056 FIELD_CELL *bp = field->buf;
3057
3058 assert(bp);
3059 while (ISBLANK(*bp))
3060 {
3061 bp++;
3062 }
3063 if (CharOf(*bp) == 0)
3064 return TRUE;
3065 }
3066
3067 if (typ->status & _LINKED_TYPE)
3068 {
3069 assert(argp);
3070 return (
3071 Check_Field(typ->left, field, argp->left) ||
3072 Check_Field(typ->right, field, argp->right));
3073 }
3074 else
3075 {
3076 if (typ->fcheck)
3077 return typ->fcheck(field, (void *)argp);
3078 }
3079 }
3080 return TRUE;
3081}
3082
3083/*---------------------------------------------------------------------------
3084| Facility : libnform
3085| Function : bool _nc_Internal_Validation(FORM * form )
3086|
3087| Description : Validate the current field of the form.
3088|
3089| Return Values : TRUE - field is valid
3090| FALSE - field is invalid
3091+--------------------------------------------------------------------------*/
3092NCURSES_EXPORT(bool)
3093_nc_Internal_Validation(FORM *form)
3094{
3095 FIELD *field;
3096
3097 field = form->current;
3098
3099 Synchronize_Buffer(form);
3100 if ((form->status & _FCHECK_REQUIRED) ||
3101 (!(field->opts & O_PASSOK)))
3102 {
3103 if (!Check_Field(field->type, field, (TypeArgument *)(field->arg)))
3104 return FALSE;
3105 form->status &= ~_FCHECK_REQUIRED;
3106 field->status |= _CHANGED;
3107 Synchronize_Linked_Fields(field);
3108 }
3109 return TRUE;
3110}
3111/*----------------------------------------------------------------------------
3112 End of Helper routines for Field Validations.
3113 --------------------------------------------------------------------------*/
3114
3115/*----------------------------------------------------------------------------
3116 Routines for Field Validation.
3117 --------------------------------------------------------------------------*/
3118
3119/*---------------------------------------------------------------------------
3120| Facility : libnform
3121| Function : static int FV_Validation(FORM * form)
3122|
3123| Description : Validate the current field of the form.
3124|
3125| Return Values : E_OK - field valid
3126| E_INVALID_FIELD - field not valid
3127+--------------------------------------------------------------------------*/
3128static int
3129FV_Validation(FORM *form)
3130{
3131 T((T_CALLED("FV_Validation(%p)"), form));
3132 if (_nc_Internal_Validation(form))
3133 returnCode(E_OK);
3134 else
3135 returnCode(E_INVALID_FIELD);
3136}
3137/*----------------------------------------------------------------------------
3138 End of routines for Field Validation.
3139 --------------------------------------------------------------------------*/
3140
3141/*----------------------------------------------------------------------------
3142 Helper routines for Inter-Field Navigation
3143 --------------------------------------------------------------------------*/
3144
3145/*---------------------------------------------------------------------------
3146| Facility : libnform
3147| Function : static FIELD *Next_Field_On_Page(FIELD * field)
3148|
3149| Description : Get the next field after the given field on the current
3150| page. The order of fields is the one defined by the
3151| fields array. Only visible and active fields are
3152| counted.
3153|
3154| Return Values : Pointer to the next field.
3155+--------------------------------------------------------------------------*/
3156NCURSES_INLINE static FIELD *
3157Next_Field_On_Page(FIELD *field)
3158{
3159 FORM *form = field->form;
3160 FIELD **field_on_page = &form->field[field->index];
3161 FIELD **first_on_page = &form->field[form->page[form->curpage].pmin];
3162 FIELD **last_on_page = &form->field[form->page[form->curpage].pmax];
3163
3164 do
3165 {
3166 field_on_page =
3167 (field_on_page == last_on_page) ? first_on_page : field_on_page + 1;
3168 if (Field_Is_Selectable(*field_on_page))
3169 break;
3170 }
3171 while (field != (*field_on_page));
3172 return (*field_on_page);
3173}
3174
3175/*---------------------------------------------------------------------------
3176| Facility : libnform
3177| Function : FIELD* _nc_First_Active_Field(FORM * form)
3178|
3179| Description : Get the first active field on the current page,
3180| if there are such. If there are none, get the first
3181| visible field on the page. If there are also none,
3182| we return the first field on page and hope the best.
3183|
3184| Return Values : Pointer to calculated field.
3185+--------------------------------------------------------------------------*/
3186NCURSES_EXPORT(FIELD *)
3187_nc_First_Active_Field(FORM *form)
3188{
3189 FIELD **last_on_page = &form->field[form->page[form->curpage].pmax];
3190 FIELD *proposed = Next_Field_On_Page(*last_on_page);
3191
3192 if (proposed == *last_on_page)
3193 {
3194 /* there might be the special situation, where there is no
3195 active and visible field on the current page. We then select
3196 the first visible field on this readonly page
3197 */
3198 if (Field_Is_Not_Selectable(proposed))
3199 {
3200 FIELD **field = &form->field[proposed->index];
3201 FIELD **first = &form->field[form->page[form->curpage].pmin];
3202
3203 do
3204 {
3205 field = (field == last_on_page) ? first : field + 1;
3206 if (((*field)->opts & O_VISIBLE))
3207 break;
3208 }
3209 while (proposed != (*field));
3210
3211 proposed = *field;
3212
3213 if ((proposed == *last_on_page) && !(proposed->opts & O_VISIBLE))
3214 {
3215 /* This means, there is also no visible field on the page.
3216 So we propose the first one and hope the very best...
3217 Some very clever user has designed a readonly and invisible
3218 page on this form.
3219 */
3220 proposed = *first;
3221 }
3222 }
3223 }
3224 return (proposed);
3225}
3226
3227/*---------------------------------------------------------------------------
3228| Facility : libnform
3229| Function : static FIELD *Previous_Field_On_Page(FIELD * field)
3230|
3231| Description : Get the previous field before the given field on the
3232| current page. The order of fields is the one defined by
3233| the fields array. Only visible and active fields are
3234| counted.
3235|
3236| Return Values : Pointer to the previous field.
3237+--------------------------------------------------------------------------*/
3238NCURSES_INLINE static FIELD *
3239Previous_Field_On_Page(FIELD *field)
3240{
3241 FORM *form = field->form;
3242 FIELD **field_on_page = &form->field[field->index];
3243 FIELD **first_on_page = &form->field[form->page[form->curpage].pmin];
3244 FIELD **last_on_page = &form->field[form->page[form->curpage].pmax];
3245
3246 do
3247 {
3248 field_on_page =
3249 (field_on_page == first_on_page) ? last_on_page : field_on_page - 1;
3250 if (Field_Is_Selectable(*field_on_page))
3251 break;
3252 }
3253 while (field != (*field_on_page));
3254
3255 return (*field_on_page);
3256}
3257
3258/*---------------------------------------------------------------------------
3259| Facility : libnform
3260| Function : static FIELD *Sorted_Next_Field(FIELD * field)
3261|
3262| Description : Get the next field after the given field on the current
3263| page. The order of fields is the one defined by the
3264| (row,column) geometry, rows are major.
3265|
3266| Return Values : Pointer to the next field.
3267+--------------------------------------------------------------------------*/
3268NCURSES_INLINE static FIELD *
3269Sorted_Next_Field(FIELD *field)
3270{
3271 FIELD *field_on_page = field;
3272
3273 do
3274 {
3275 field_on_page = field_on_page->snext;
3276 if (Field_Is_Selectable(field_on_page))
3277 break;
3278 }
3279 while (field_on_page != field);
3280
3281 return (field_on_page);
3282}
3283
3284/*---------------------------------------------------------------------------
3285| Facility : libnform
3286| Function : static FIELD *Sorted_Previous_Field(FIELD * field)
3287|
3288| Description : Get the previous field before the given field on the
3289| current page. The order of fields is the one defined
3290| by the (row,column) geometry, rows are major.
3291|
3292| Return Values : Pointer to the previous field.
3293+--------------------------------------------------------------------------*/
3294NCURSES_INLINE static FIELD *
3295Sorted_Previous_Field(FIELD *field)
3296{
3297 FIELD *field_on_page = field;
3298
3299 do
3300 {
3301 field_on_page = field_on_page->sprev;
3302 if (Field_Is_Selectable(field_on_page))
3303 break;
3304 }
3305 while (field_on_page != field);
3306
3307 return (field_on_page);
3308}
3309
3310/*---------------------------------------------------------------------------
3311| Facility : libnform
3312| Function : static FIELD *Left_Neighbor_Field(FIELD * field)
3313|
3314| Description : Get the left neighbor of the field on the same line
3315| and the same page. Cycles through the line.
3316|
3317| Return Values : Pointer to left neighbor field.
3318+--------------------------------------------------------------------------*/
3319NCURSES_INLINE static FIELD *
3320Left_Neighbor_Field(FIELD *field)
3321{
3322 FIELD *field_on_page = field;
3323
3324 /* For a field that has really a left neighbor, the while clause
3325 immediately fails and the loop is left, positioned at the right
3326 neighbor. Otherwise we cycle backwards through the sorted field list
3327 until we enter the same line (from the right end).
3328 */
3329 do
3330 {
3331 field_on_page = Sorted_Previous_Field(field_on_page);
3332 }
3333 while (field_on_page->frow != field->frow);
3334
3335 return (field_on_page);
3336}
3337
3338/*---------------------------------------------------------------------------
3339| Facility : libnform
3340| Function : static FIELD *Right_Neighbor_Field(FIELD * field)
3341|
3342| Description : Get the right neighbor of the field on the same line
3343| and the same page.
3344|
3345| Return Values : Pointer to right neighbor field.
3346+--------------------------------------------------------------------------*/
3347NCURSES_INLINE static FIELD *
3348Right_Neighbor_Field(FIELD *field)
3349{
3350 FIELD *field_on_page = field;
3351
3352 /* See the comments on Left_Neighbor_Field to understand how it works */
3353 do
3354 {
3355 field_on_page = Sorted_Next_Field(field_on_page);
3356 }
3357 while (field_on_page->frow != field->frow);
3358
3359 return (field_on_page);
3360}
3361
3362/*---------------------------------------------------------------------------
3363| Facility : libnform
3364| Function : static FIELD *Upper_Neighbor_Field(FIELD * field)
3365|
3366| Description : Because of the row-major nature of sorting the fields,
3367| it is more difficult to define whats the upper neighbor
3368| field really means. We define that it must be on a
3369| 'previous' line (cyclic order!) and is the rightmost
3370| field laying on the left side of the given field. If
3371| this set is empty, we take the first field on the line.
3372|
3373| Return Values : Pointer to the upper neighbor field.
3374+--------------------------------------------------------------------------*/
3375static FIELD *
3376Upper_Neighbor_Field(FIELD *field)
3377{
3378 FIELD *field_on_page = field;
3379 int frow = field->frow;
3380 int fcol = field->fcol;
3381
3382 /* Walk back to the 'previous' line. The second term in the while clause
3383 just guarantees that we stop if we cycled through the line because
3384 there might be no 'previous' line if the page has just one line.
3385 */
3386 do
3387 {
3388 field_on_page = Sorted_Previous_Field(field_on_page);
3389 }
3390 while (field_on_page->frow == frow && field_on_page->fcol != fcol);
3391
3392 if (field_on_page->frow != frow)
3393 {
3394 /* We really found a 'previous' line. We are positioned at the
3395 rightmost field on this line */
3396 frow = field_on_page->frow;
3397
3398 /* We walk to the left as long as we are really right of the
3399 field. */
3400 while (field_on_page->frow == frow && field_on_page->fcol > fcol)
3401 field_on_page = Sorted_Previous_Field(field_on_page);
3402
3403 /* If we wrapped, just go to the right which is the first field on
3404 the row */
3405 if (field_on_page->frow != frow)
3406 field_on_page = Sorted_Next_Field(field_on_page);
3407 }
3408
3409 return (field_on_page);
3410}
3411
3412/*---------------------------------------------------------------------------
3413| Facility : libnform
3414| Function : static FIELD *Down_Neighbor_Field(FIELD * field)
3415|
3416| Description : Because of the row-major nature of sorting the fields,
3417| its more difficult to define whats the down neighbor
3418| field really means. We define that it must be on a
3419| 'next' line (cyclic order!) and is the leftmost
3420| field laying on the right side of the given field. If
3421| this set is empty, we take the last field on the line.
3422|
3423| Return Values : Pointer to the upper neighbor field.
3424+--------------------------------------------------------------------------*/
3425static FIELD *
3426Down_Neighbor_Field(FIELD *field)
3427{
3428 FIELD *field_on_page = field;
3429 int frow = field->frow;
3430 int fcol = field->fcol;
3431
3432 /* Walk forward to the 'next' line. The second term in the while clause
3433 just guarantees that we stop if we cycled through the line because
3434 there might be no 'next' line if the page has just one line.
3435 */
3436 do
3437 {
3438 field_on_page = Sorted_Next_Field(field_on_page);
3439 }
3440 while (field_on_page->frow == frow && field_on_page->fcol != fcol);
3441
3442 if (field_on_page->frow != frow)
3443 {
3444 /* We really found a 'next' line. We are positioned at the rightmost
3445 field on this line */
3446 frow = field_on_page->frow;
3447
3448 /* We walk to the right as long as we are really left of the
3449 field. */
3450 while (field_on_page->frow == frow && field_on_page->fcol < fcol)
3451 field_on_page = Sorted_Next_Field(field_on_page);
3452
3453 /* If we wrapped, just go to the left which is the last field on
3454 the row */
3455 if (field_on_page->frow != frow)
3456 field_on_page = Sorted_Previous_Field(field_on_page);
3457 }
3458
3459 return (field_on_page);
3460}
3461
3462/*----------------------------------------------------------------------------
3463 Inter-Field Navigation routines
3464 --------------------------------------------------------------------------*/
3465
3466/*---------------------------------------------------------------------------
3467| Facility : libnform
3468| Function : static int Inter_Field_Navigation(
3469| int (* const fct) (FORM *),
3470| FORM * form)
3471|
3472| Description : Generic behavior for changing the current field, the
3473| field is left and a new field is entered. So the field
3474| must be validated and the field init/term hooks must
3475| be called.
3476|
3477| Return Values : E_OK - success
3478| E_INVALID_FIELD - field is invalid
3479| some other - error from subordinate call
3480+--------------------------------------------------------------------------*/
3481static int
3482Inter_Field_Navigation(int (*const fct) (FORM *), FORM *form)
3483{
3484 int res;
3485
3486 if (!_nc_Internal_Validation(form))
3487 res = E_INVALID_FIELD;
3488 else
3489 {
3490 Call_Hook(form, fieldterm);
3491 res = fct(form);
3492 Call_Hook(form, fieldinit);
3493 }
3494 return res;
3495}
3496
3497/*---------------------------------------------------------------------------
3498| Facility : libnform
3499| Function : static int FN_Next_Field(FORM * form)
3500|
3501| Description : Move to the next field on the current page of the form
3502|
3503| Return Values : E_OK - success
3504| != E_OK - error from subordinate call
3505+--------------------------------------------------------------------------*/
3506static int
3507FN_Next_Field(FORM *form)
3508{
3509 T((T_CALLED("FN_Next_Field(%p)"), form));
3510 returnCode(_nc_Set_Current_Field(form,
3511 Next_Field_On_Page(form->current)));
3512}
3513
3514/*---------------------------------------------------------------------------
3515| Facility : libnform
3516| Function : static int FN_Previous_Field(FORM * form)
3517|
3518| Description : Move to the previous field on the current page of the
3519| form
3520|
3521| Return Values : E_OK - success
3522| != E_OK - error from subordinate call
3523+--------------------------------------------------------------------------*/
3524static int
3525FN_Previous_Field(FORM *form)
3526{
3527 T((T_CALLED("FN_Previous_Field(%p)"), form));
3528 returnCode(_nc_Set_Current_Field(form,
3529 Previous_Field_On_Page(form->current)));
3530}
3531
3532/*---------------------------------------------------------------------------
3533| Facility : libnform
3534| Function : static int FN_First_Field(FORM * form)
3535|
3536| Description : Move to the first field on the current page of the form
3537|
3538| Return Values : E_OK - success
3539| != E_OK - error from subordinate call
3540+--------------------------------------------------------------------------*/
3541static int
3542FN_First_Field(FORM *form)
3543{
3544 T((T_CALLED("FN_First_Field(%p)"), form));
3545 returnCode(_nc_Set_Current_Field(form,
3546 Next_Field_On_Page(form->field[form->page[form->curpage].pmax])));
3547}
3548
3549/*---------------------------------------------------------------------------
3550| Facility : libnform
3551| Function : static int FN_Last_Field(FORM * form)
3552|
3553| Description : Move to the last field on the current page of the form
3554|
3555| Return Values : E_OK - success
3556| != E_OK - error from subordinate call
3557+--------------------------------------------------------------------------*/
3558static int
3559FN_Last_Field(FORM *form)
3560{
3561 T((T_CALLED("FN_Last_Field(%p)"), form));
3562 returnCode(
3563 _nc_Set_Current_Field(form,
3564 Previous_Field_On_Page(form->field[form->page[form->curpage].pmin])));
3565}
3566
3567/*---------------------------------------------------------------------------
3568| Facility : libnform
3569| Function : static int FN_Sorted_Next_Field(FORM * form)
3570|
3571| Description : Move to the sorted next field on the current page
3572| of the form.
3573|
3574| Return Values : E_OK - success
3575| != E_OK - error from subordinate call
3576+--------------------------------------------------------------------------*/
3577static int
3578FN_Sorted_Next_Field(FORM *form)
3579{
3580 T((T_CALLED("FN_Sorted_Next_Field(%p)"), form));
3581 returnCode(_nc_Set_Current_Field(form,
3582 Sorted_Next_Field(form->current)));
3583}
3584
3585/*---------------------------------------------------------------------------
3586| Facility : libnform
3587| Function : static int FN_Sorted_Previous_Field(FORM * form)
3588|
3589| Description : Move to the sorted previous field on the current page
3590| of the form.
3591|
3592| Return Values : E_OK - success
3593| != E_OK - error from subordinate call
3594+--------------------------------------------------------------------------*/
3595static int
3596FN_Sorted_Previous_Field(FORM *form)
3597{
3598 T((T_CALLED("FN_Sorted_Previous_Field(%p)"), form));
3599 returnCode(_nc_Set_Current_Field(form,
3600 Sorted_Previous_Field(form->current)));
3601}
3602
3603/*---------------------------------------------------------------------------
3604| Facility : libnform
3605| Function : static int FN_Sorted_First_Field(FORM * form)
3606|
3607| Description : Move to the sorted first field on the current page
3608| of the form.
3609|
3610| Return Values : E_OK - success
3611| != E_OK - error from subordinate call
3612+--------------------------------------------------------------------------*/
3613static int
3614FN_Sorted_First_Field(FORM *form)
3615{
3616 T((T_CALLED("FN_Sorted_First_Field(%p)"), form));
3617 returnCode(_nc_Set_Current_Field(form,
3618 Sorted_Next_Field(form->field[form->page[form->curpage].smax])));
3619}
3620
3621/*---------------------------------------------------------------------------
3622| Facility : libnform
3623| Function : static int FN_Sorted_Last_Field(FORM * form)
3624|
3625| Description : Move to the sorted last field on the current page
3626| of the form.
3627|
3628| Return Values : E_OK - success
3629| != E_OK - error from subordinate call
3630+--------------------------------------------------------------------------*/
3631static int
3632FN_Sorted_Last_Field(FORM *form)
3633{
3634 T((T_CALLED("FN_Sorted_Last_Field(%p)"), form));
3635 returnCode(_nc_Set_Current_Field(form,
3636 Sorted_Previous_Field(form->field[form->page[form->curpage].smin])));
3637}
3638
3639/*---------------------------------------------------------------------------
3640| Facility : libnform
3641| Function : static int FN_Left_Field(FORM * form)
3642|
3643| Description : Get the field on the left of the current field on the
3644| same line and the same page. Cycles through the line.
3645|
3646| Return Values : E_OK - success
3647| != E_OK - error from subordinate call
3648+--------------------------------------------------------------------------*/
3649static int
3650FN_Left_Field(FORM *form)
3651{
3652 T((T_CALLED("FN_Left_Field(%p)"), form));
3653 returnCode(_nc_Set_Current_Field(form,
3654 Left_Neighbor_Field(form->current)));
3655}
3656
3657/*---------------------------------------------------------------------------
3658| Facility : libnform
3659| Function : static int FN_Right_Field(FORM * form)
3660|
3661| Description : Get the field on the right of the current field on the
3662| same line and the same page. Cycles through the line.
3663|
3664| Return Values : E_OK - success
3665| != E_OK - error from subordinate call
3666+--------------------------------------------------------------------------*/
3667static int
3668FN_Right_Field(FORM *form)
3669{
3670 T((T_CALLED("FN_Right_Field(%p)"), form));
3671 returnCode(_nc_Set_Current_Field(form,
3672 Right_Neighbor_Field(form->current)));
3673}
3674
3675/*---------------------------------------------------------------------------
3676| Facility : libnform
3677| Function : static int FN_Up_Field(FORM * form)
3678|
3679| Description : Get the upper neighbor of the current field. This
3680| cycles through the page. See the comments of the
3681| Upper_Neighbor_Field function to understand how
3682| 'upper' is defined.
3683|
3684| Return Values : E_OK - success
3685| != E_OK - error from subordinate call
3686+--------------------------------------------------------------------------*/
3687static int
3688FN_Up_Field(FORM *form)
3689{
3690 T((T_CALLED("FN_Up_Field(%p)"), form));
3691 returnCode(_nc_Set_Current_Field(form,
3692 Upper_Neighbor_Field(form->current)));
3693}
3694
3695/*---------------------------------------------------------------------------
3696| Facility : libnform
3697| Function : static int FN_Down_Field(FORM * form)
3698|
3699| Description : Get the down neighbor of the current field. This
3700| cycles through the page. See the comments of the
3701| Down_Neighbor_Field function to understand how
3702| 'down' is defined.
3703|
3704| Return Values : E_OK - success
3705| != E_OK - error from subordinate call
3706+--------------------------------------------------------------------------*/
3707static int
3708FN_Down_Field(FORM *form)
3709{
3710 T((T_CALLED("FN_Down_Field(%p)"), form));
3711 returnCode(_nc_Set_Current_Field(form,
3712 Down_Neighbor_Field(form->current)));
3713}
3714/*----------------------------------------------------------------------------
3715 END of Field Navigation routines
3716 --------------------------------------------------------------------------*/
3717
3718/*----------------------------------------------------------------------------
3719 Helper routines for Page Navigation
3720 --------------------------------------------------------------------------*/
3721
3722/*---------------------------------------------------------------------------
3723| Facility : libnform
3724| Function : int _nc_Set_Form_Page(FORM * form,
3725| int page,
3726| FIELD * field)
3727|
3728| Description : Make the given page number the current page and make
3729| the given field the current field on the page. If
3730| for the field NULL is given, make the first field on
3731| the page the current field. The routine acts only
3732| if the requested page is not the current page.
3733|
3734| Return Values : E_OK - success
3735| != E_OK - error from subordinate call
3736| E_BAD_ARGUMENT - invalid field pointer
3737| E_SYSTEM_ERROR - some severe basic error
3738+--------------------------------------------------------------------------*/
3739NCURSES_EXPORT(int)
3740_nc_Set_Form_Page(FORM *form, int page, FIELD *field)
3741{
3742 int res = E_OK;
3743
3744 if ((form->curpage != page))
3745 {
3746 FIELD *last_field, *field_on_page;
3747
3748 werase(Get_Form_Window(form));
3749 form->curpage = page;
3750 last_field = field_on_page = form->field[form->page[page].smin];
3751 do
3752 {
3753 if (field_on_page->opts & O_VISIBLE)
3754 if ((res = Display_Field(field_on_page)) != E_OK)
3755 return (res);
3756 field_on_page = field_on_page->snext;
3757 }
3758 while (field_on_page != last_field);
3759
3760 if (field)
3761 res = _nc_Set_Current_Field(form, field);
3762 else
3763 /* N.B.: we don't encapsulate this by Inter_Field_Navigation(),
3764 because this is already executed in a page navigation
3765 context that contains field navigation
3766 */
3767 res = FN_First_Field(form);
3768 }
3769 return (res);
3770}
3771
3772/*---------------------------------------------------------------------------
3773| Facility : libnform
3774| Function : static int Next_Page_Number(const FORM * form)
3775|
3776| Description : Calculate the page number following the current page
3777| number. This cycles if the highest page number is
3778| reached.
3779|
3780| Return Values : The next page number
3781+--------------------------------------------------------------------------*/
3782NCURSES_INLINE static int
3783Next_Page_Number(const FORM *form)
3784{
3785 return (form->curpage + 1) % form->maxpage;
3786}
3787
3788/*---------------------------------------------------------------------------
3789| Facility : libnform
3790| Function : static int Previous_Page_Number(const FORM * form)
3791|
3792| Description : Calculate the page number before the current page
3793| number. This cycles if the first page number is
3794| reached.
3795|
3796| Return Values : The previous page number
3797+--------------------------------------------------------------------------*/
3798NCURSES_INLINE static int
3799Previous_Page_Number(const FORM *form)
3800{
3801 return (form->curpage != 0 ? form->curpage - 1 : form->maxpage - 1);
3802}
3803
3804/*----------------------------------------------------------------------------
3805 Page Navigation routines
3806 --------------------------------------------------------------------------*/
3807
3808/*---------------------------------------------------------------------------
3809| Facility : libnform
3810| Function : static int Page_Navigation(
3811| int (* const fct) (FORM *),
3812| FORM * form)
3813|
3814| Description : Generic behavior for changing a page. This means
3815| that the field is left and a new field is entered.
3816| So the field must be validated and the field init/term
3817| hooks must be called. Because also the page is changed,
3818| the forms init/term hooks must be called also.
3819|
3820| Return Values : E_OK - success
3821| E_INVALID_FIELD - field is invalid
3822| some other - error from subordinate call
3823+--------------------------------------------------------------------------*/
3824static int
3825Page_Navigation(int (*const fct) (FORM *), FORM *form)
3826{
3827 int res;
3828
3829 if (!_nc_Internal_Validation(form))
3830 res = E_INVALID_FIELD;
3831 else
3832 {
3833 Call_Hook(form, fieldterm);
3834 Call_Hook(form, formterm);
3835 res = fct(form);
3836 Call_Hook(form, forminit);
3837 Call_Hook(form, fieldinit);
3838 }
3839 return res;
3840}
3841
3842/*---------------------------------------------------------------------------
3843| Facility : libnform
3844| Function : static int PN_Next_Page(FORM * form)
3845|
3846| Description : Move to the next page of the form
3847|
3848| Return Values : E_OK - success
3849| != E_OK - error from subordinate call
3850+--------------------------------------------------------------------------*/
3851static int
3852PN_Next_Page(FORM *form)
3853{
3854 T((T_CALLED("PN_Next_Page(%p)"), form));
3855 returnCode(_nc_Set_Form_Page(form, Next_Page_Number(form), (FIELD *)0));
3856}
3857
3858/*---------------------------------------------------------------------------
3859| Facility : libnform
3860| Function : static int PN_Previous_Page(FORM * form)
3861|
3862| Description : Move to the previous page of the form
3863|
3864| Return Values : E_OK - success
3865| != E_OK - error from subordinate call
3866+--------------------------------------------------------------------------*/
3867static int
3868PN_Previous_Page(FORM *form)
3869{
3870 T((T_CALLED("PN_Previous_Page(%p)"), form));
3871 returnCode(_nc_Set_Form_Page(form, Previous_Page_Number(form), (FIELD *)0));
3872}
3873
3874/*---------------------------------------------------------------------------
3875| Facility : libnform
3876| Function : static int PN_First_Page(FORM * form)
3877|
3878| Description : Move to the first page of the form
3879|
3880| Return Values : E_OK - success
3881| != E_OK - error from subordinate call
3882+--------------------------------------------------------------------------*/
3883static int
3884PN_First_Page(FORM *form)
3885{
3886 T((T_CALLED("PN_First_Page(%p)"), form));
3887 returnCode(_nc_Set_Form_Page(form, 0, (FIELD *)0));
3888}
3889
3890/*---------------------------------------------------------------------------
3891| Facility : libnform
3892| Function : static int PN_Last_Page(FORM * form)
3893|
3894| Description : Move to the last page of the form
3895|
3896| Return Values : E_OK - success
3897| != E_OK - error from subordinate call
3898+--------------------------------------------------------------------------*/
3899static int
3900PN_Last_Page(FORM *form)
3901{
3902 T((T_CALLED("PN_Last_Page(%p)"), form));
3903 returnCode(_nc_Set_Form_Page(form, form->maxpage - 1, (FIELD *)0));
3904}
3905
3906/*----------------------------------------------------------------------------
3907 END of Field Navigation routines
3908 --------------------------------------------------------------------------*/
3909
3910/*----------------------------------------------------------------------------
3911 Helper routines for the core form driver.
3912 --------------------------------------------------------------------------*/
3913
3914/*---------------------------------------------------------------------------
3915| Facility : libnform
3916| Function : static int Data_Entry(FORM * form,int c)
3917|
3918| Description : Enter character c into at the current position of the
3919| current field of the form.
3920|
3921| Return Values : E_OK - success
3922| E_REQUEST_DENIED - driver could not process the request
3923| E_SYSTEM_ERROR -
3924+--------------------------------------------------------------------------*/
3925static int
3926Data_Entry(FORM *form, int c)
3927{
3928 FIELD *field = form->current;
3929 int result = E_REQUEST_DENIED;
3930
3931 T((T_CALLED("Data_Entry(%p,%s)"), form, _tracechtype((chtype)c)));
3932 if ((field->opts & O_EDIT)
3933#if FIX_FORM_INACTIVE_BUG
3934 && (field->opts & O_ACTIVE)
3935#endif
3936 )
3937 {
3938 if ((field->opts & O_BLANK) &&
3939 First_Position_In_Current_Field(form) &&
3940 !(form->status & _FCHECK_REQUIRED) &&
3941 !(form->status & _WINDOW_MODIFIED))
3942 werase(form->w);
3943
3944 if (form->status & _OVLMODE)
3945 {
3946 waddch(form->w, (chtype)c);
3947 }
3948 else
3949 /* no _OVLMODE */
3950 {
3951 bool There_Is_Room = Is_There_Room_For_A_Char_In_Line(form);
3952
3953 if (!(There_Is_Room ||
3954 ((Single_Line_Field(field) && Growable(field)))))
3955 RETURN(E_REQUEST_DENIED);
3956
3957 if (!There_Is_Room && !Field_Grown(field, 1))
3958 RETURN(E_SYSTEM_ERROR);
3959
3960 winsch(form->w, (chtype)c);
3961 }
3962
3963 if ((result = Wrapping_Not_Necessary_Or_Wrapping_Ok(form)) == E_OK)
3964 {
3965 bool End_Of_Field = (((field->drows - 1) == form->currow) &&
3966 ((field->dcols - 1) == form->curcol));
3967
3968 form->status |= _WINDOW_MODIFIED;
3969 if (End_Of_Field && !Growable(field) && (field->opts & O_AUTOSKIP))
3970 result = Inter_Field_Navigation(FN_Next_Field, form);
3971 else
3972 {
3973 if (End_Of_Field && Growable(field) && !Field_Grown(field, 1))
3974 result = E_SYSTEM_ERROR;
3975 else
3976 {
3977#if USE_WIDEC_SUPPORT
3978 /*
3979 * We have just added a byte to the form field. It may have
3980 * been part of a multibyte character. If it was, the
3981 * addch_used field is nonzero and we should not try to move
3982 * to a new column.
3983 */
3984 if (WINDOW_EXT(form->w, addch_used) == 0)
3985 IFN_Next_Character(form);
3986#else
3987 IFN_Next_Character(form);
3988#endif
3989 result = E_OK;
3990 }
3991 }
3992 }
3993 }
3994 RETURN(result);
3995}
3996
3997/* Structure to describe the binding of a request code to a function.
3998 The member keycode codes the request value as well as the generic
3999 routine to use for the request. The code for the generic routine
4000 is coded in the upper 16 Bits while the request code is coded in
4001 the lower 16 bits.
4002
4003 In terms of C++ you might think of a request as a class with a
4004 virtual method "perform". The different types of request are
4005 derived from this base class and overload (or not) the base class
4006 implementation of perform.
4007*/
4008typedef struct
4009{
4010 int keycode; /* must be at least 32 bit: hi:mode, lo: key */
4011 int (*cmd) (FORM *); /* low level driver routine for this key */
4012}
4013Binding_Info;
4014
4015/* You may see this is the class-id of the request type class */
4016#define ID_PN (0x00000000) /* Page navigation */
4017#define ID_FN (0x00010000) /* Inter-Field navigation */
4018#define ID_IFN (0x00020000) /* Intra-Field navigation */
4019#define ID_VSC (0x00030000) /* Vertical Scrolling */
4020#define ID_HSC (0x00040000) /* Horizontal Scrolling */
4021#define ID_FE (0x00050000) /* Field Editing */
4022#define ID_EM (0x00060000) /* Edit Mode */
4023#define ID_FV (0x00070000) /* Field Validation */
4024#define ID_CH (0x00080000) /* Choice */
4025#define ID_Mask (0xffff0000)
4026#define Key_Mask (0x0000ffff)
4027#define ID_Shft (16)
4028
4029/* This array holds all the Binding Infos */
4030/* *INDENT-OFF* */
4031static const Binding_Info bindings[MAX_FORM_COMMAND - MIN_FORM_COMMAND + 1] =
4032{
4033 { REQ_NEXT_PAGE |ID_PN ,PN_Next_Page},
4034 { REQ_PREV_PAGE |ID_PN ,PN_Previous_Page},
4035 { REQ_FIRST_PAGE |ID_PN ,PN_First_Page},
4036 { REQ_LAST_PAGE |ID_PN ,PN_Last_Page},
4037
4038 { REQ_NEXT_FIELD |ID_FN ,FN_Next_Field},
4039 { REQ_PREV_FIELD |ID_FN ,FN_Previous_Field},
4040 { REQ_FIRST_FIELD |ID_FN ,FN_First_Field},
4041 { REQ_LAST_FIELD |ID_FN ,FN_Last_Field},
4042 { REQ_SNEXT_FIELD |ID_FN ,FN_Sorted_Next_Field},
4043 { REQ_SPREV_FIELD |ID_FN ,FN_Sorted_Previous_Field},
4044 { REQ_SFIRST_FIELD |ID_FN ,FN_Sorted_First_Field},
4045 { REQ_SLAST_FIELD |ID_FN ,FN_Sorted_Last_Field},
4046 { REQ_LEFT_FIELD |ID_FN ,FN_Left_Field},
4047 { REQ_RIGHT_FIELD |ID_FN ,FN_Right_Field},
4048 { REQ_UP_FIELD |ID_FN ,FN_Up_Field},
4049 { REQ_DOWN_FIELD |ID_FN ,FN_Down_Field},
4050
4051 { REQ_NEXT_CHAR |ID_IFN ,IFN_Next_Character},
4052 { REQ_PREV_CHAR |ID_IFN ,IFN_Previous_Character},
4053 { REQ_NEXT_LINE |ID_IFN ,IFN_Next_Line},
4054 { REQ_PREV_LINE |ID_IFN ,IFN_Previous_Line},
4055 { REQ_NEXT_WORD |ID_IFN ,IFN_Next_Word},
4056 { REQ_PREV_WORD |ID_IFN ,IFN_Previous_Word},
4057 { REQ_BEG_FIELD |ID_IFN ,IFN_Beginning_Of_Field},
4058 { REQ_END_FIELD |ID_IFN ,IFN_End_Of_Field},
4059 { REQ_BEG_LINE |ID_IFN ,IFN_Beginning_Of_Line},
4060 { REQ_END_LINE |ID_IFN ,IFN_End_Of_Line},
4061 { REQ_LEFT_CHAR |ID_IFN ,IFN_Left_Character},
4062 { REQ_RIGHT_CHAR |ID_IFN ,IFN_Right_Character},
4063 { REQ_UP_CHAR |ID_IFN ,IFN_Up_Character},
4064 { REQ_DOWN_CHAR |ID_IFN ,IFN_Down_Character},
4065
4066 { REQ_NEW_LINE |ID_FE ,FE_New_Line},
4067 { REQ_INS_CHAR |ID_FE ,FE_Insert_Character},
4068 { REQ_INS_LINE |ID_FE ,FE_Insert_Line},
4069 { REQ_DEL_CHAR |ID_FE ,FE_Delete_Character},
4070 { REQ_DEL_PREV |ID_FE ,FE_Delete_Previous},
4071 { REQ_DEL_LINE |ID_FE ,FE_Delete_Line},
4072 { REQ_DEL_WORD |ID_FE ,FE_Delete_Word},
4073 { REQ_CLR_EOL |ID_FE ,FE_Clear_To_End_Of_Line},
4074 { REQ_CLR_EOF |ID_FE ,FE_Clear_To_End_Of_Field},
4075 { REQ_CLR_FIELD |ID_FE ,FE_Clear_Field},
4076
4077 { REQ_OVL_MODE |ID_EM ,EM_Overlay_Mode},
4078 { REQ_INS_MODE |ID_EM ,EM_Insert_Mode},
4079
4080 { REQ_SCR_FLINE |ID_VSC ,VSC_Scroll_Line_Forward},
4081 { REQ_SCR_BLINE |ID_VSC ,VSC_Scroll_Line_Backward},
4082 { REQ_SCR_FPAGE |ID_VSC ,VSC_Scroll_Page_Forward},
4083 { REQ_SCR_BPAGE |ID_VSC ,VSC_Scroll_Page_Backward},
4084 { REQ_SCR_FHPAGE |ID_VSC ,VSC_Scroll_Half_Page_Forward},
4085 { REQ_SCR_BHPAGE |ID_VSC ,VSC_Scroll_Half_Page_Backward},
4086
4087 { REQ_SCR_FCHAR |ID_HSC ,HSC_Scroll_Char_Forward},
4088 { REQ_SCR_BCHAR |ID_HSC ,HSC_Scroll_Char_Backward},
4089 { REQ_SCR_HFLINE |ID_HSC ,HSC_Horizontal_Line_Forward},
4090 { REQ_SCR_HBLINE |ID_HSC ,HSC_Horizontal_Line_Backward},
4091 { REQ_SCR_HFHALF |ID_HSC ,HSC_Horizontal_Half_Line_Forward},
4092 { REQ_SCR_HBHALF |ID_HSC ,HSC_Horizontal_Half_Line_Backward},
4093
4094 { REQ_VALIDATION |ID_FV ,FV_Validation},
4095
4096 { REQ_NEXT_CHOICE |ID_CH ,CR_Next_Choice},
4097 { REQ_PREV_CHOICE |ID_CH ,CR_Previous_Choice}
4098};
4099/* *INDENT-ON* */
4100
4101/*---------------------------------------------------------------------------
4102| Facility : libnform
4103| Function : int form_driver(FORM * form,int c)
4104|
4105| Description : This is the workhorse of the forms system. It checks
4106| to determine whether the character c is a request or
4107| data. If it is a request, the form driver executes
4108| the request and returns the result. If it is data
4109| (printable character), it enters the data into the
4110| current position in the current field. If it is not
4111| recognized, the form driver assumes it is an application
4112| defined command and returns E_UNKNOWN_COMMAND.
4113| Application defined command should be defined relative
4114| to MAX_FORM_COMMAND, the maximum value of a request.
4115|
4116| Return Values : E_OK - success
4117| E_SYSTEM_ERROR - system error
4118| E_BAD_ARGUMENT - an argument is incorrect
4119| E_NOT_POSTED - form is not posted
4120| E_INVALID_FIELD - field contents are invalid
4121| E_BAD_STATE - called from inside a hook routine
4122| E_REQUEST_DENIED - request failed
4123| E_NOT_CONNECTED - no fields are connected to the form
4124| E_UNKNOWN_COMMAND - command not known
4125+--------------------------------------------------------------------------*/
4126NCURSES_EXPORT(int)
4127form_driver(FORM *form, int c)
4128{
4129 const Binding_Info *BI = (Binding_Info *) 0;
4130 int res = E_UNKNOWN_COMMAND;
4131
4132 T((T_CALLED("form_driver(%p,%d)"), form, c));
4133
4134 if (!form)
4135 RETURN(E_BAD_ARGUMENT);
4136
4137 if (!(form->field))
4138 RETURN(E_NOT_CONNECTED);
4139
4140 assert(form->page);
4141
4142 if (c == FIRST_ACTIVE_MAGIC)
4143 {
4144 form->current = _nc_First_Active_Field(form);
4145 RETURN(E_OK);
4146 }
4147
4148 assert(form->current &&
4149 form->current->buf &&
4150 (form->current->form == form)
4151 );
4152
4153 if (form->status & _IN_DRIVER)
4154 RETURN(E_BAD_STATE);
4155
4156 if (!(form->status & _POSTED))
4157 RETURN(E_NOT_POSTED);
4158
4159 if ((c >= MIN_FORM_COMMAND && c <= MAX_FORM_COMMAND) &&
4160 ((bindings[c - MIN_FORM_COMMAND].keycode & Key_Mask) == c))
4161 BI = &(bindings[c - MIN_FORM_COMMAND]);
4162
4163 if (BI)
4164 {
4165 typedef int (*Generic_Method) (int (*const) (FORM *), FORM *);
4166 static const Generic_Method Generic_Methods[] =
4167 {
4168 Page_Navigation, /* overloaded to call field&form hooks */
4169 Inter_Field_Navigation, /* overloaded to call field hooks */
4170 NULL, /* Intra-Field is generic */
4171 Vertical_Scrolling, /* Overloaded to check multi-line */
4172 Horizontal_Scrolling, /* Overloaded to check single-line */
4173 Field_Editing, /* Overloaded to mark modification */
4174 NULL, /* Edit Mode is generic */
4175 NULL, /* Field Validation is generic */
4176 NULL /* Choice Request is generic */
4177 };
4178 size_t nMethods = (sizeof(Generic_Methods) / sizeof(Generic_Methods[0]));
4179 size_t method = ((BI->keycode & ID_Mask) >> ID_Shft) & 0xffff;
4180
4181 if ((method >= nMethods) || !(BI->cmd))
4182 res = E_SYSTEM_ERROR;
4183 else
4184 {
4185 Generic_Method fct = Generic_Methods[method];
4186
4187 if (fct)
4188 res = fct(BI->cmd, form);
4189 else
4190 res = (BI->cmd) (form);
4191 }
4192 }
4193#ifdef NCURSES_MOUSE_VERSION
4194 else if (KEY_MOUSE == c)
4195 {
4196 MEVENT event;
4197 WINDOW *win = form->win ? form->win : stdscr;
4198 WINDOW *sub = form->sub ? form->sub : win;
4199
4200 getmouse(&event);
4201 if ((event.bstate & (BUTTON1_CLICKED |
4202 BUTTON1_DOUBLE_CLICKED |
4203 BUTTON1_TRIPLE_CLICKED))
4204 && wenclose(win, event.y, event.x))
4205 { /* we react only if the click was in the userwin, that means
4206 * inside the form display area or at the decoration window.
4207 */
4208 int ry = event.y, rx = event.x; /* screen coordinates */
4209
4210 res = E_REQUEST_DENIED;
4211 if (mouse_trafo(&ry, &rx, FALSE))
4212 { /* rx, ry are now "curses" coordinates */
4213 if (ry < sub->_begy)
4214 { /* we clicked above the display region; this is
4215 * interpreted as "scroll up" request
4216 */
4217 if (event.bstate & BUTTON1_CLICKED)
4218 res = form_driver(form, REQ_PREV_FIELD);
4219 else if (event.bstate & BUTTON1_DOUBLE_CLICKED)
4220 res = form_driver(form, REQ_PREV_PAGE);
4221 else if (event.bstate & BUTTON1_TRIPLE_CLICKED)
4222 res = form_driver(form, REQ_FIRST_FIELD);
4223 }
4224 else if (ry > sub->_begy + sub->_maxy)
4225 { /* we clicked below the display region; this is
4226 * interpreted as "scroll down" request
4227 */
4228 if (event.bstate & BUTTON1_CLICKED)
4229 res = form_driver(form, REQ_NEXT_FIELD);
4230 else if (event.bstate & BUTTON1_DOUBLE_CLICKED)
4231 res = form_driver(form, REQ_NEXT_PAGE);
4232 else if (event.bstate & BUTTON1_TRIPLE_CLICKED)
4233 res = form_driver(form, REQ_LAST_FIELD);
4234 }
4235 else if (wenclose(sub, event.y, event.x))
4236 { /* Inside the area we try to find the hit item */
4237 int i;
4238
4239 ry = event.y;
4240 rx = event.x;
4241 if (wmouse_trafo(sub, &ry, &rx, FALSE))
4242 {
4243 int min_field = form->page[form->curpage].pmin;
4244 int max_field = form->page[form->curpage].pmax;
4245
4246 for (i = min_field; i <= max_field; ++i)
4247 {
4248 FIELD *field = form->field[i];
4249
4250 if (Field_Is_Selectable(field)
4251 && Field_encloses(field, ry, rx) == E_OK)
4252 {
4253 res = _nc_Set_Current_Field(form, field);
4254 if (res == E_OK)
4255 res = _nc_Position_Form_Cursor(form);
4256 if (res == E_OK
4257 && (event.bstate & BUTTON1_DOUBLE_CLICKED))
4258 res = E_UNKNOWN_COMMAND;
4259 break;
4260 }
4261 }
4262 }
4263 }
4264 }
4265 }
4266 else
4267 res = E_REQUEST_DENIED;
4268 }
4269#endif /* NCURSES_MOUSE_VERSION */
4270 else if (!(c & (~(int)MAX_REGULAR_CHARACTER)))
4271 {
4272 /*
4273 * If we're using 8-bit characters, iscntrl+isprint cover the whole set.
4274 * But with multibyte characters, there is a third possibility, i.e.,
4275 * parts of characters that build up into printable characters which are
4276 * not considered printable.
4277 *
4278 * FIXME: the wide-character branch should also use Check_Char().
4279 */
4280#if USE_WIDEC_SUPPORT
4281 if (!iscntrl(UChar(c)))
4282#else
4283 if (isprint(UChar(c)) &&
4284 Check_Char(form->current->type, c,
4285 (TypeArgument *)(form->current->arg)))
4286#endif
4287 res = Data_Entry(form, c);
4288 }
4289 _nc_Refresh_Current_Field(form);
4290 RETURN(res);
4291}
4292
4293/*----------------------------------------------------------------------------
4294 Field-Buffer manipulation routines.
4295 The effects of setting a buffer are tightly coupled to the core of the form
4296 driver logic. This is especially true in the case of growable fields.
4297 So I don't separate this into a separate module.
4298 --------------------------------------------------------------------------*/
4299
4300/*---------------------------------------------------------------------------
4301| Facility : libnform
4302| Function : int set_field_buffer(FIELD *field,
4303| int buffer, char *value)
4304|
4305| Description : Set the given buffer of the field to the given value.
4306| Buffer 0 stores the displayed content of the field.
4307| For dynamic fields this may grow the fieldbuffers if
4308| the length of the value exceeds the current buffer
4309| length. For buffer 0 only printable values are allowed.
4310| For static fields, the value needs not to be zero ter-
4311| minated. It is copied up to the length of the buffer.
4312|
4313| Return Values : E_OK - success
4314| E_BAD_ARGUMENT - invalid argument
4315| E_SYSTEM_ERROR - system error
4316+--------------------------------------------------------------------------*/
4317NCURSES_EXPORT(int)
4318set_field_buffer(FIELD *field, int buffer, const char *value)
4319{
4320 FIELD_CELL *p;
4321 int res = E_OK;
4322 unsigned int i;
4323 unsigned int len;
4324
4325#if USE_WIDEC_SUPPORT
4326 FIELD_CELL *widevalue = 0;
4327#endif
4328
4329 T((T_CALLED("set_field_buffer(%p,%d,%s)"), field, buffer, _nc_visbuf(value)));
4330
4331 if (!field || !value || ((buffer < 0) || (buffer > field->nbuf)))
4332 RETURN(E_BAD_ARGUMENT);
4333
4334 len = Buffer_Length(field);
4335
4336 if (buffer == 0)
4337 {
4338 for (i = 0; (value[i] != '\0') && (i < len); ++i)
4339 {
4340 if (iscntrl(UChar(value[i])))
4341 RETURN(E_BAD_ARGUMENT);
4342 }
4343 }
4344
4345 if (Growable(field))
4346 {
4347 /* for a growable field we must assume zero terminated strings, because
4348 somehow we have to detect the length of what should be copied.
4349 */
4350 unsigned int vlen = strlen(value);
4351
4352 if (vlen > len)
4353 {
4354 if (!Field_Grown(field,
4355 (int)(1 + (vlen - len) / ((field->rows + field->nrow)
4356 * field->cols))))
4357 RETURN(E_SYSTEM_ERROR);
4358
4359 /* in this case we also have to check, whether or not the remaining
4360 characters in value are also printable for buffer 0. */
4361 if (buffer == 0)
4362 {
4363 for (i = len; i < vlen; i++)
4364 if (iscntrl(UChar(value[i])))
4365 RETURN(E_BAD_ARGUMENT);
4366 }
4367 len = vlen;
4368 }
4369 }
4370
4371 p = Address_Of_Nth_Buffer(field, buffer);
4372
4373#if USE_WIDEC_SUPPORT
4374 /*
4375 * Use addstr's logic for converting a string to an array of cchar_t's.
4376 * There should be a better way, but this handles nonspacing characters
4377 * and other special cases that we really do not want to handle here.
4378 */
4379 wclear(field->working);
4380 mvwaddstr(field->working, 0, 0, value);
4381
4382 if ((widevalue = typeCalloc(FIELD_CELL, len + 1)) == 0)
4383 {
4384 RETURN(E_SYSTEM_ERROR);
4385 }
4386 else
4387 {
4388 mvwin_wchnstr(field->working, 0, 0, widevalue, (int)len);
4389 for (i = 0; i < len; ++i)
4390 {
4391 if (CharEq(myZEROS, widevalue[i]))
4392 {
4393 while (i < len)
4394 p[i++] = myBLANK;
4395 break;
4396 }
4397 p[i] = widevalue[i];
4398 }
4399 free(widevalue);
4400 }
4401#else
4402 for (i = 0; i < len; ++i)
4403 {
4404 if (value[i] == '\0')
4405 {
4406 while (i < len)
4407 p[i++] = myBLANK;
4408 break;
4409 }
4410 p[i] = value[i];
4411 }
4412#endif
4413
4414 if (buffer == 0)
4415 {
4416 int syncres;
4417
4418 if (((syncres = Synchronize_Field(field)) != E_OK) &&
4419 (res == E_OK))
4420 res = syncres;
4421 if (((syncres = Synchronize_Linked_Fields(field)) != E_OK) &&
4422 (res == E_OK))
4423 res = syncres;
4424 }
4425 RETURN(res);
4426}
4427
4428/*---------------------------------------------------------------------------
4429| Facility : libnform
4430| Function : char *field_buffer(const FIELD *field,int buffer)
4431|
4432| Description : Return the address of the buffer for the field.
4433|
4434| Return Values : Pointer to buffer or NULL if arguments were invalid.
4435+--------------------------------------------------------------------------*/
4436NCURSES_EXPORT(char *)
4437field_buffer(const FIELD *field, int buffer)
4438{
4439 char *result = 0;
4440
4441 T((T_CALLED("field_buffer(%p,%d)"), field, buffer));
4442
4443 if (field && (buffer >= 0) && (buffer <= field->nbuf))
4444 {
4445#if USE_WIDEC_SUPPORT
4446 FIELD_CELL *data = Address_Of_Nth_Buffer(field, buffer);
4447 unsigned need = 0;
4448 int size = Buffer_Length(field);
4449 int n;
4450
4451 /* determine the number of bytes needed to store the expanded string */
4452 for (n = 0; n < size; ++n)
4453 {
4454 if (!isWidecExt(data[n]))
4455 {
4456 mbstate_t state;
4457 size_t next;
4458
4459 init_mb(state);
4460 next = _nc_wcrtomb(0, data[n].chars[0], &state);
4461 if (!isEILSEQ(next))
4462 need += next;
4463 }
4464 }
4465
4466 /* allocate a place to store the expanded string */
4467 if (field->expanded[buffer] != 0)
4468 free(field->expanded[buffer]);
4469 field->expanded[buffer] = typeMalloc(char, need + 1);
4470
4471 /* expand the multibyte data */
4472 if ((result = field->expanded[buffer]) != 0)
4473 {
4474 wclear(field->working);
4475 mvwadd_wchnstr(field->working, 0, 0, data, size);
4476 mvwinnstr(field->working, 0, 0, result, (int)need);
4477 }
4478#else
4479 result = Address_Of_Nth_Buffer(field, buffer);
4480#endif
4481 }
4482 returnPtr(result);
4483}
4484
4485#if USE_WIDEC_SUPPORT
4486
4487/* FIXME: see lib_get_wch.c */
4488#if HAVE_MBTOWC && HAVE_MBLEN
4489#define reset_mbytes(state) mblen(NULL, 0), mbtowc(NULL, NULL, 0)
4490#define count_mbytes(buffer,length,state) mblen(buffer,length)
4491#define trans_mbytes(wch,buffer,length,state) \
4492 (int) mbtowc(&wch, buffer, length)
4493#elif HAVE_MBRTOWC && HAVE_MBRLEN
4494#define NEED_STATE
4495#define reset_mbytes(state) init_mb(state)
4496#define count_mbytes(buffer,length,state) mbrlen(buffer,length,&state)
4497#define trans_mbytes(wch,buffer,length,state) \
4498 (int) mbrtowc(&wch, buffer, length, &state)
4499#else
4500make an error
4501#endif
4502
4503/*---------------------------------------------------------------------------
4504| Convert a multibyte string to a wide-character string. The result must be
4505| freed by the caller.
4506+--------------------------------------------------------------------------*/
4507NCURSES_EXPORT(wchar_t *)
4508_nc_Widen_String(char *source, int *lengthp)
4509{
4510 wchar_t *result = 0;
4511 wchar_t wch;
4512 size_t given = strlen(source);
4513 size_t tries;
4514 int pass;
4515 int status;
4516
4517#ifdef NEED_STATE
4518 mbstate_t state;
4519#endif
4520
4521 for (pass = 0; pass < 2; ++pass)
4522 {
4523 unsigned need = 0;
4524 size_t passed = 0;
4525
4526 while (passed < given)
4527 {
4528 bool found = FALSE;
4529
4530 for (tries = 1, status = 0; tries <= (given - passed); ++tries)
4531 {
4532 int save = source[passed + tries];
4533
4534 source[passed + tries] = 0;
4535 reset_mbytes(state);
4536 status = trans_mbytes(wch, source + passed, tries, state);
4537 source[passed + tries] = save;
4538
4539 if (status > 0)
4540 {
4541 found = TRUE;
4542 break;
4543 }
4544 }
4545 if (found)
4546 {
4547 if (pass)
4548 {
4549 result[need] = wch;
4550 }
4551 passed += status;
4552 ++need;
4553 }
4554 else
4555 {
4556 if (pass)
4557 {
4558 result[need] = source[passed];
4559 }
4560 ++need;
4561 ++passed;
4562 }
4563 }
4564
4565 if (!pass)
4566 {
4567 if (!need)
4568 break;
4569 result = typeCalloc(wchar_t, need);
4570
4571 *lengthp = need;
4572 if (result == 0)
4573 break;
4574 }
4575 }
4576
4577 return result;
4578}
4579#endif
4580
4581/* frm_driver.c ends here */
| 680 if (wresize(field->working, 1, Buffer_Length(field) + 1) == ERR)
681 result = FALSE;
682#endif
683
684 if (need_visual_update && result)
685 {
686 WINDOW *new_window = newpad(field->drows, field->dcols);
687
688 if (new_window != 0)
689 {
690 assert(form != (FORM *)0);
691 if (form->w)
692 delwin(form->w);
693 form->w = new_window;
694 Set_Field_Window_Attributes(field, form->w);
695 werase(form->w);
696 Buffer_To_Window(field, form->w);
697 untouchwin(form->w);
698 wmove(form->w, form->currow, form->curcol);
699 }
700 else
701 result = FALSE;
702 }
703
704 if (result)
705 {
706 free(oldbuf);
707 /* reflect changes in linked fields */
708 if (field != field->link)
709 {
710 FIELD *linked_field;
711
712 for (linked_field = field->link;
713 linked_field != field;
714 linked_field = linked_field->link)
715 {
716 linked_field->buf = field->buf;
717 linked_field->drows = field->drows;
718 linked_field->dcols = field->dcols;
719 }
720 }
721 }
722 else
723 {
724 /* restore old state */
725 field->dcols = old_dcols;
726 field->drows = old_drows;
727 field->buf = oldbuf;
728 if ((single_line_field &&
729 (field->dcols != field->maxgrow)) ||
730 (!single_line_field &&
731 (field->drows != field->maxgrow)))
732 field->status |= _MAY_GROW;
733 free(newbuf);
734 }
735 }
736 }
737 return (result);
738}
739
740#ifdef NCURSES_MOUSE_VERSION
741/*---------------------------------------------------------------------------
742| Facility : libnform
743| Function : int Field_encloses(FIELD *field, int ry, int rx)
744|
745| Description : Check if the given coordinates lie within the given field.
746|
747| Return Values : E_OK - success
748| E_BAD_ARGUMENT - invalid form pointer
749| E_SYSTEM_ERROR - form has no current field or
750| field-window
751+--------------------------------------------------------------------------*/
752static int
753Field_encloses(FIELD *field, int ry, int rx)
754{
755 T((T_CALLED("Field_encloses(%p)"), field));
756 if (field != 0
757 && field->frow <= ry
758 && (field->frow + field->rows) > ry
759 && field->fcol <= rx
760 && (field->fcol + field->cols) > rx)
761 {
762 RETURN(E_OK);
763 }
764 RETURN(E_INVALID_FIELD);
765}
766#endif
767
768/*---------------------------------------------------------------------------
769| Facility : libnform
770| Function : int _nc_Position_Form_Cursor(FORM * form)
771|
772| Description : Position the cursor in the window for the current
773| field to be in sync. with the currow and curcol
774| values.
775|
776| Return Values : E_OK - success
777| E_BAD_ARGUMENT - invalid form pointer
778| E_SYSTEM_ERROR - form has no current field or
779| field-window
780+--------------------------------------------------------------------------*/
781NCURSES_EXPORT(int)
782_nc_Position_Form_Cursor(FORM *form)
783{
784 FIELD *field;
785 WINDOW *formwin;
786
787 if (!form)
788 return (E_BAD_ARGUMENT);
789
790 if (!form->w || !form->current)
791 return (E_SYSTEM_ERROR);
792
793 field = form->current;
794 formwin = Get_Form_Window(form);
795
796 wmove(form->w, form->currow, form->curcol);
797 if (Has_Invisible_Parts(field))
798 {
799 /* in this case fieldwin isn't derived from formwin, so we have
800 to move the cursor in formwin by hand... */
801 wmove(formwin,
802 field->frow + form->currow - form->toprow,
803 field->fcol + form->curcol - form->begincol);
804 wcursyncup(formwin);
805 }
806 else
807 wcursyncup(form->w);
808 return (E_OK);
809}
810
811/*---------------------------------------------------------------------------
812| Facility : libnform
813| Function : int _nc_Refresh_Current_Field(FORM * form)
814|
815| Description : Propagate the changes in the fields window to the
816| window of the form.
817|
818| Return Values : E_OK - on success
819| E_BAD_ARGUMENT - invalid form pointer
820| E_SYSTEM_ERROR - general error
821+--------------------------------------------------------------------------*/
822NCURSES_EXPORT(int)
823_nc_Refresh_Current_Field(FORM *form)
824{
825 WINDOW *formwin;
826 FIELD *field;
827
828 T((T_CALLED("_nc_Refresh_Current_Field(%p)"), form));
829
830 if (!form)
831 RETURN(E_BAD_ARGUMENT);
832
833 if (!form->w || !form->current)
834 RETURN(E_SYSTEM_ERROR);
835
836 field = form->current;
837 formwin = Get_Form_Window(form);
838
839 if (field->opts & O_PUBLIC)
840 {
841 if (Is_Scroll_Field(field))
842 {
843 /* Again, in this case the fieldwin isn't derived from formwin,
844 so we have to perform a copy operation. */
845 if (Single_Line_Field(field))
846 {
847 /* horizontal scrolling */
848 if (form->curcol < form->begincol)
849 form->begincol = form->curcol;
850 else
851 {
852 if (form->curcol >= (form->begincol + field->cols))
853 form->begincol = form->curcol - field->cols + 1;
854 }
855 copywin(form->w,
856 formwin,
857 0,
858 form->begincol,
859 field->frow,
860 field->fcol,
861 field->frow,
862 field->cols + field->fcol - 1,
863 0);
864 }
865 else
866 {
867 /* A multi-line, i.e. vertical scrolling field */
868 int row_after_bottom, first_modified_row, first_unmodified_row;
869
870 if (field->drows > field->rows)
871 {
872 row_after_bottom = form->toprow + field->rows;
873 if (form->currow < form->toprow)
874 {
875 form->toprow = form->currow;
876 field->status |= _NEWTOP;
877 }
878 if (form->currow >= row_after_bottom)
879 {
880 form->toprow = form->currow - field->rows + 1;
881 field->status |= _NEWTOP;
882 }
883 if (field->status & _NEWTOP)
884 {
885 /* means we have to copy whole range */
886 first_modified_row = form->toprow;
887 first_unmodified_row = first_modified_row + field->rows;
888 field->status &= ~_NEWTOP;
889 }
890 else
891 {
892 /* we try to optimize : finding the range of touched
893 lines */
894 first_modified_row = form->toprow;
895 while (first_modified_row < row_after_bottom)
896 {
897 if (is_linetouched(form->w, first_modified_row))
898 break;
899 first_modified_row++;
900 }
901 first_unmodified_row = first_modified_row;
902 while (first_unmodified_row < row_after_bottom)
903 {
904 if (!is_linetouched(form->w, first_unmodified_row))
905 break;
906 first_unmodified_row++;
907 }
908 }
909 }
910 else
911 {
912 first_modified_row = form->toprow;
913 first_unmodified_row = first_modified_row + field->rows;
914 }
915 if (first_unmodified_row != first_modified_row)
916 copywin(form->w,
917 formwin,
918 first_modified_row,
919 0,
920 field->frow + first_modified_row - form->toprow,
921 field->fcol,
922 field->frow + first_unmodified_row - form->toprow - 1,
923 field->cols + field->fcol - 1,
924 0);
925 }
926 wsyncup(formwin);
927 }
928 else
929 {
930 /* if the field-window is simply a derived window, i.e. contains no
931 * invisible parts, the whole thing is trivial
932 */
933 wsyncup(form->w);
934 }
935 }
936 untouchwin(form->w);
937 returnCode(_nc_Position_Form_Cursor(form));
938}
939
940/*---------------------------------------------------------------------------
941| Facility : libnform
942| Function : static void Perform_Justification(
943| FIELD * field,
944| WINDOW * win)
945|
946| Description : Output field with requested justification
947|
948| Return Values : -
949+--------------------------------------------------------------------------*/
950static void
951Perform_Justification(FIELD *field, WINDOW *win)
952{
953 FIELD_CELL *bp;
954 int len;
955 int col = 0;
956
957 bp = Get_Start_Of_Data(field->buf, Buffer_Length(field));
958 len = (int)(After_End_Of_Data(field->buf, Buffer_Length(field)) - bp);
959
960 if (len > 0)
961 {
962 assert(win && (field->drows == 1) && (field->dcols == field->cols));
963
964 switch (field->just)
965 {
966 case JUSTIFY_LEFT:
967 break;
968 case JUSTIFY_CENTER:
969 col = (field->cols - len) / 2;
970 break;
971 case JUSTIFY_RIGHT:
972 col = field->cols - len;
973 break;
974 default:
975 break;
976 }
977
978 wmove(win, 0, col);
979 myADDNSTR(win, bp, len);
980 }
981}
982
983/*---------------------------------------------------------------------------
984| Facility : libnform
985| Function : static void Undo_Justification(
986| FIELD * field,
987| WINDOW * win)
988|
989| Description : Display field without any justification, i.e.
990| left justified
991|
992| Return Values : -
993+--------------------------------------------------------------------------*/
994static void
995Undo_Justification(FIELD *field, WINDOW *win)
996{
997 FIELD_CELL *bp;
998 int len;
999
1000 bp = Get_Start_Of_Data(field->buf, Buffer_Length(field));
1001 len = (int)(After_End_Of_Data(field->buf, Buffer_Length(field)) - bp);
1002
1003 if (len > 0)
1004 {
1005 assert(win);
1006 wmove(win, 0, 0);
1007 myADDNSTR(win, bp, len);
1008 }
1009}
1010
1011/*---------------------------------------------------------------------------
1012| Facility : libnform
1013| Function : static bool Check_Char(
1014| FIELDTYPE * typ,
1015| int ch,
1016| TypeArgument *argp)
1017|
1018| Description : Perform a single character check for character ch
1019| according to the fieldtype instance.
1020|
1021| Return Values : TRUE - Character is valid
1022| FALSE - Character is invalid
1023+--------------------------------------------------------------------------*/
1024static bool
1025Check_Char(FIELDTYPE *typ, int ch, TypeArgument *argp)
1026{
1027 if (typ)
1028 {
1029 if (typ->status & _LINKED_TYPE)
1030 {
1031 assert(argp);
1032 return (
1033 Check_Char(typ->left, ch, argp->left) ||
1034 Check_Char(typ->right, ch, argp->right));
1035 }
1036 else
1037 {
1038 if (typ->ccheck)
1039 return typ->ccheck(ch, (void *)argp);
1040 }
1041 }
1042 return (!iscntrl(UChar(ch)) ? TRUE : FALSE);
1043}
1044
1045/*---------------------------------------------------------------------------
1046| Facility : libnform
1047| Function : static int Display_Or_Erase_Field(
1048| FIELD * field,
1049| bool bEraseFlag)
1050|
1051| Description : Create a subwindow for the field and display the
1052| buffer contents (apply justification if required)
1053| or simply erase the field.
1054|
1055| Return Values : E_OK - on success
1056| E_SYSTEM_ERROR - some error (typical no memory)
1057+--------------------------------------------------------------------------*/
1058static int
1059Display_Or_Erase_Field(FIELD *field, bool bEraseFlag)
1060{
1061 WINDOW *win;
1062 WINDOW *fwin;
1063
1064 if (!field)
1065 return E_SYSTEM_ERROR;
1066
1067 fwin = Get_Form_Window(field->form);
1068 win = derwin(fwin,
1069 field->rows, field->cols, field->frow, field->fcol);
1070
1071 if (!win)
1072 return E_SYSTEM_ERROR;
1073 else
1074 {
1075 if (field->opts & O_VISIBLE)
1076 Set_Field_Window_Attributes(field, win);
1077 else
1078 wattrset(win, WINDOW_ATTRS(fwin));
1079 werase(win);
1080 }
1081
1082 if (!bEraseFlag)
1083 {
1084 if (field->opts & O_PUBLIC)
1085 {
1086 if (Justification_Allowed(field))
1087 Perform_Justification(field, win);
1088 else
1089 Buffer_To_Window(field, win);
1090 }
1091 field->status &= ~_NEWTOP;
1092 }
1093 wsyncup(win);
1094 delwin(win);
1095 return E_OK;
1096}
1097
1098/* Macros to preset the bEraseFlag */
1099#define Display_Field(field) Display_Or_Erase_Field(field,FALSE)
1100#define Erase_Field(field) Display_Or_Erase_Field(field,TRUE)
1101
1102/*---------------------------------------------------------------------------
1103| Facility : libnform
1104| Function : static int Synchronize_Field(FIELD * field)
1105|
1106| Description : Synchronize the windows content with the value in
1107| the buffer.
1108|
1109| Return Values : E_OK - success
1110| E_BAD_ARGUMENT - invalid field pointer
1111| E_SYSTEM_ERROR - some severe basic error
1112+--------------------------------------------------------------------------*/
1113static int
1114Synchronize_Field(FIELD *field)
1115{
1116 FORM *form;
1117 int res = E_OK;
1118
1119 if (!field)
1120 return (E_BAD_ARGUMENT);
1121
1122 if (((form = field->form) != (FORM *)0)
1123 && Field_Really_Appears(field))
1124 {
1125 if (field == form->current)
1126 {
1127 form->currow = form->curcol = form->toprow = form->begincol = 0;
1128 werase(form->w);
1129
1130 if ((field->opts & O_PUBLIC) && Justification_Allowed(field))
1131 Undo_Justification(field, form->w);
1132 else
1133 Buffer_To_Window(field, form->w);
1134
1135 field->status |= _NEWTOP;
1136 res = _nc_Refresh_Current_Field(form);
1137 }
1138 else
1139 res = Display_Field(field);
1140 }
1141 field->status |= _CHANGED;
1142 return (res);
1143}
1144
1145/*---------------------------------------------------------------------------
1146| Facility : libnform
1147| Function : static int Synchronize_Linked_Fields(FIELD * field)
1148|
1149| Description : Propagate the Synchronize_Field function to all linked
1150| fields. The first error that occurs in the sequence
1151| of updates is the return value.
1152|
1153| Return Values : E_OK - success
1154| E_BAD_ARGUMENT - invalid field pointer
1155| E_SYSTEM_ERROR - some severe basic error
1156+--------------------------------------------------------------------------*/
1157static int
1158Synchronize_Linked_Fields(FIELD *field)
1159{
1160 FIELD *linked_field;
1161 int res = E_OK;
1162 int syncres;
1163
1164 if (!field)
1165 return (E_BAD_ARGUMENT);
1166
1167 if (!field->link)
1168 return (E_SYSTEM_ERROR);
1169
1170 for (linked_field = field->link;
1171 linked_field != field;
1172 linked_field = linked_field->link)
1173 {
1174 if (((syncres = Synchronize_Field(linked_field)) != E_OK) &&
1175 (res == E_OK))
1176 res = syncres;
1177 }
1178 return (res);
1179}
1180
1181/*---------------------------------------------------------------------------
1182| Facility : libnform
1183| Function : int _nc_Synchronize_Attributes(FIELD * field)
1184|
1185| Description : If a fields visual attributes have changed, this
1186| routine is called to propagate those changes to the
1187| screen.
1188|
1189| Return Values : E_OK - success
1190| E_BAD_ARGUMENT - invalid field pointer
1191| E_SYSTEM_ERROR - some severe basic error
1192+--------------------------------------------------------------------------*/
1193NCURSES_EXPORT(int)
1194_nc_Synchronize_Attributes(FIELD *field)
1195{
1196 FORM *form;
1197 int res = E_OK;
1198 WINDOW *formwin;
1199
1200 T((T_CALLED("_nc_Synchronize_Attributes(%p)"), field));
1201
1202 if (!field)
1203 returnCode(E_BAD_ARGUMENT);
1204
1205 CHECKPOS(field->form);
1206 if (((form = field->form) != (FORM *)0)
1207 && Field_Really_Appears(field))
1208 {
1209 if (form->current == field)
1210 {
1211 Synchronize_Buffer(form);
1212 Set_Field_Window_Attributes(field, form->w);
1213 werase(form->w);
1214 wmove(form->w, form->currow, form->curcol);
1215
1216 if (field->opts & O_PUBLIC)
1217 {
1218 if (Justification_Allowed(field))
1219 Undo_Justification(field, form->w);
1220 else
1221 Buffer_To_Window(field, form->w);
1222 }
1223 else
1224 {
1225 formwin = Get_Form_Window(form);
1226 copywin(form->w, formwin,
1227 0, 0,
1228 field->frow, field->fcol,
1229 field->rows - 1, field->cols - 1, 0);
1230 wsyncup(formwin);
1231 Buffer_To_Window(field, form->w);
1232 field->status |= _NEWTOP; /* fake refresh to paint all */
1233 _nc_Refresh_Current_Field(form);
1234 }
1235 }
1236 else
1237 {
1238 res = Display_Field(field);
1239 }
1240 }
1241 CHECKPOS(form);
1242 returnCode(res);
1243}
1244
1245/*---------------------------------------------------------------------------
1246| Facility : libnform
1247| Function : int _nc_Synchronize_Options(FIELD * field,
1248| Field_Options newopts)
1249|
1250| Description : If a fields options have changed, this routine is
1251| called to propagate these changes to the screen and
1252| to really change the behavior of the field.
1253|
1254| Return Values : E_OK - success
1255| E_BAD_ARGUMENT - invalid field pointer
1256| E_CURRENT - field is the current one
1257| E_SYSTEM_ERROR - some severe basic error
1258+--------------------------------------------------------------------------*/
1259NCURSES_EXPORT(int)
1260_nc_Synchronize_Options(FIELD *field, Field_Options newopts)
1261{
1262 Field_Options oldopts;
1263 Field_Options changed_opts;
1264 FORM *form;
1265 int res = E_OK;
1266
1267 T((T_CALLED("_nc_Synchronize_Options(%p,%#x)"), field, newopts));
1268
1269 if (!field)
1270 returnCode(E_BAD_ARGUMENT);
1271
1272 oldopts = field->opts;
1273 changed_opts = oldopts ^ newopts;
1274 field->opts = newopts;
1275 form = field->form;
1276
1277 if (form)
1278 {
1279 if (form->current == field)
1280 {
1281 field->opts = oldopts;
1282 returnCode(E_CURRENT);
1283 }
1284
1285 if (form->status & _POSTED)
1286 {
1287 if ((form->curpage == field->page))
1288 {
1289 if (changed_opts & O_VISIBLE)
1290 {
1291 if (newopts & O_VISIBLE)
1292 res = Display_Field(field);
1293 else
1294 res = Erase_Field(field);
1295 }
1296 else
1297 {
1298 if ((changed_opts & O_PUBLIC) &&
1299 (newopts & O_VISIBLE))
1300 res = Display_Field(field);
1301 }
1302 }
1303 }
1304 }
1305
1306 if (changed_opts & O_STATIC)
1307 {
1308 bool single_line_field = Single_Line_Field(field);
1309 int res2 = E_OK;
1310
1311 if (newopts & O_STATIC)
1312 {
1313 /* the field becomes now static */
1314 field->status &= ~_MAY_GROW;
1315 /* if actually we have no hidden columns, justification may
1316 occur again */
1317 if (single_line_field &&
1318 (field->cols == field->dcols) &&
1319 (field->just != NO_JUSTIFICATION) &&
1320 Field_Really_Appears(field))
1321 {
1322 res2 = Display_Field(field);
1323 }
1324 }
1325 else
1326 {
1327 /* field is no longer static */
1328 if ((field->maxgrow == 0) ||
1329 (single_line_field && (field->dcols < field->maxgrow)) ||
1330 (!single_line_field && (field->drows < field->maxgrow)))
1331 {
1332 field->status |= _MAY_GROW;
1333 /* a field with justification now changes its behavior,
1334 so we must redisplay it */
1335 if (single_line_field &&
1336 (field->just != NO_JUSTIFICATION) &&
1337 Field_Really_Appears(field))
1338 {
1339 res2 = Display_Field(field);
1340 }
1341 }
1342 }
1343 if (res2 != E_OK)
1344 res = res2;
1345 }
1346
1347 returnCode(res);
1348}
1349
1350/*---------------------------------------------------------------------------
1351| Facility : libnform
1352| Function : int _nc_Set_Current_Field(FORM * form,
1353| FIELD * newfield)
1354|
1355| Description : Make the newfield the new current field.
1356|
1357| Return Values : E_OK - success
1358| E_BAD_ARGUMENT - invalid form or field pointer
1359| E_SYSTEM_ERROR - some severe basic error
1360| E_NOT_CONNECTED - no fields are connected to the form
1361+--------------------------------------------------------------------------*/
1362NCURSES_EXPORT(int)
1363_nc_Set_Current_Field(FORM *form, FIELD *newfield)
1364{
1365 FIELD *field;
1366 WINDOW *new_window;
1367
1368 T((T_CALLED("_nc_Set_Current_Field(%p,%p)"), form, newfield));
1369
1370 if (!form || !newfield || !form->current || (newfield->form != form))
1371 returnCode(E_BAD_ARGUMENT);
1372
1373 if ((form->status & _IN_DRIVER))
1374 returnCode(E_BAD_STATE);
1375
1376 if (!(form->field))
1377 returnCode(E_NOT_CONNECTED);
1378
1379 field = form->current;
1380
1381 if ((field != newfield) ||
1382 !(form->status & _POSTED))
1383 {
1384 if ((form->w) &&
1385 (field->opts & O_VISIBLE) &&
1386 (field->form->curpage == field->page))
1387 {
1388 _nc_Refresh_Current_Field(form);
1389 if (field->opts & O_PUBLIC)
1390 {
1391 if (field->drows > field->rows)
1392 {
1393 if (form->toprow == 0)
1394 field->status &= ~_NEWTOP;
1395 else
1396 field->status |= _NEWTOP;
1397 }
1398 else
1399 {
1400 if (Justification_Allowed(field))
1401 {
1402 Window_To_Buffer(form->w, field);
1403 werase(form->w);
1404 Perform_Justification(field, form->w);
1405 wsyncup(form->w);
1406 }
1407 }
1408 }
1409 delwin(form->w);
1410 form->w = (WINDOW *)0;
1411 }
1412
1413 field = newfield;
1414
1415 if (Has_Invisible_Parts(field))
1416 new_window = newpad(field->drows, field->dcols);
1417 else
1418 new_window = derwin(Get_Form_Window(form),
1419 field->rows, field->cols, field->frow, field->fcol);
1420
1421 if (!new_window)
1422 returnCode(E_SYSTEM_ERROR);
1423
1424 form->current = field;
1425
1426 if (form->w)
1427 delwin(form->w);
1428 form->w = new_window;
1429
1430 form->status &= ~_WINDOW_MODIFIED;
1431 Set_Field_Window_Attributes(field, form->w);
1432
1433 if (Has_Invisible_Parts(field))
1434 {
1435 werase(form->w);
1436 Buffer_To_Window(field, form->w);
1437 }
1438 else
1439 {
1440 if (Justification_Allowed(field))
1441 {
1442 werase(form->w);
1443 Undo_Justification(field, form->w);
1444 wsyncup(form->w);
1445 }
1446 }
1447
1448 untouchwin(form->w);
1449 }
1450
1451 form->currow = form->curcol = form->toprow = form->begincol = 0;
1452 returnCode(E_OK);
1453}
1454
1455/*----------------------------------------------------------------------------
1456 Intra-Field Navigation routines
1457 --------------------------------------------------------------------------*/
1458
1459/*---------------------------------------------------------------------------
1460| Facility : libnform
1461| Function : static int IFN_Next_Character(FORM * form)
1462|
1463| Description : Move to the next character in the field. In a multi-line
1464| field this wraps at the end of the line.
1465|
1466| Return Values : E_OK - success
1467| E_REQUEST_DENIED - at the rightmost position
1468+--------------------------------------------------------------------------*/
1469static int
1470IFN_Next_Character(FORM *form)
1471{
1472 FIELD *field = form->current;
1473 int step = myWCWIDTH(form->w, form->currow, form->curcol);
1474
1475 T((T_CALLED("IFN_Next_Character(%p)"), form));
1476 if ((form->curcol += step) == field->dcols)
1477 {
1478 if ((++(form->currow)) == field->drows)
1479 {
1480#if GROW_IF_NAVIGATE
1481 if (!Single_Line_Field(field) && Field_Grown(field, 1))
1482 {
1483 form->curcol = 0;
1484 returnCode(E_OK);
1485 }
1486#endif
1487 form->currow--;
1488#if GROW_IF_NAVIGATE
1489 if (Single_Line_Field(field) && Field_Grown(field, 1))
1490 returnCode(E_OK);
1491#endif
1492 form->curcol -= step;
1493 returnCode(E_REQUEST_DENIED);
1494 }
1495 form->curcol = 0;
1496 }
1497 returnCode(E_OK);
1498}
1499
1500/*---------------------------------------------------------------------------
1501| Facility : libnform
1502| Function : static int IFN_Previous_Character(FORM * form)
1503|
1504| Description : Move to the previous character in the field. In a
1505| multi-line field this wraps and the beginning of the
1506| line.
1507|
1508| Return Values : E_OK - success
1509| E_REQUEST_DENIED - at the leftmost position
1510+--------------------------------------------------------------------------*/
1511static int
1512IFN_Previous_Character(FORM *form)
1513{
1514 int amount = myWCWIDTH(form->w, form->currow, form->curcol - 1);
1515 int oldcol = form->curcol;
1516
1517 T((T_CALLED("IFN_Previous_Character(%p)"), form));
1518 if ((form->curcol -= amount) < 0)
1519 {
1520 if ((--(form->currow)) < 0)
1521 {
1522 form->currow++;
1523 form->curcol = oldcol;
1524 returnCode(E_REQUEST_DENIED);
1525 }
1526 form->curcol = form->current->dcols - 1;
1527 }
1528 returnCode(E_OK);
1529}
1530
1531/*---------------------------------------------------------------------------
1532| Facility : libnform
1533| Function : static int IFN_Next_Line(FORM * form)
1534|
1535| Description : Move to the beginning of the next line in the field
1536|
1537| Return Values : E_OK - success
1538| E_REQUEST_DENIED - at the last line
1539+--------------------------------------------------------------------------*/
1540static int
1541IFN_Next_Line(FORM *form)
1542{
1543 FIELD *field = form->current;
1544
1545 T((T_CALLED("IFN_Next_Line(%p)"), form));
1546 if ((++(form->currow)) == field->drows)
1547 {
1548#if GROW_IF_NAVIGATE
1549 if (!Single_Line_Field(field) && Field_Grown(field, 1))
1550 returnCode(E_OK);
1551#endif
1552 form->currow--;
1553 returnCode(E_REQUEST_DENIED);
1554 }
1555 form->curcol = 0;
1556 returnCode(E_OK);
1557}
1558
1559/*---------------------------------------------------------------------------
1560| Facility : libnform
1561| Function : static int IFN_Previous_Line(FORM * form)
1562|
1563| Description : Move to the beginning of the previous line in the field
1564|
1565| Return Values : E_OK - success
1566| E_REQUEST_DENIED - at the first line
1567+--------------------------------------------------------------------------*/
1568static int
1569IFN_Previous_Line(FORM *form)
1570{
1571 T((T_CALLED("IFN_Previous_Line(%p)"), form));
1572 if ((--(form->currow)) < 0)
1573 {
1574 form->currow++;
1575 returnCode(E_REQUEST_DENIED);
1576 }
1577 form->curcol = 0;
1578 returnCode(E_OK);
1579}
1580
1581/*---------------------------------------------------------------------------
1582| Facility : libnform
1583| Function : static int IFN_Next_Word(FORM * form)
1584|
1585| Description : Move to the beginning of the next word in the field.
1586|
1587| Return Values : E_OK - success
1588| E_REQUEST_DENIED - there is no next word
1589+--------------------------------------------------------------------------*/
1590static int
1591IFN_Next_Word(FORM *form)
1592{
1593 FIELD *field = form->current;
1594 FIELD_CELL *bp = Address_Of_Current_Position_In_Buffer(form);
1595 FIELD_CELL *s;
1596 FIELD_CELL *t;
1597
1598 T((T_CALLED("IFN_Next_Word(%p)"), form));
1599
1600 /* We really need access to the data, so we have to synchronize */
1601 Synchronize_Buffer(form);
1602
1603 /* Go to the first whitespace after the current position (including
1604 current position). This is then the starting point to look for the
1605 next non-blank data */
1606 s = Get_First_Whitespace_Character(bp, Buffer_Length(field) -
1607 (int)(bp - field->buf));
1608
1609 /* Find the start of the next word */
1610 t = Get_Start_Of_Data(s, Buffer_Length(field) -
1611 (int)(s - field->buf));
1612#if !FRIENDLY_PREV_NEXT_WORD
1613 if (s == t)
1614 returnCode(E_REQUEST_DENIED);
1615 else
1616#endif
1617 {
1618 Adjust_Cursor_Position(form, t);
1619 returnCode(E_OK);
1620 }
1621}
1622
1623/*---------------------------------------------------------------------------
1624| Facility : libnform
1625| Function : static int IFN_Previous_Word(FORM * form)
1626|
1627| Description : Move to the beginning of the previous word in the field.
1628|
1629| Return Values : E_OK - success
1630| E_REQUEST_DENIED - there is no previous word
1631+--------------------------------------------------------------------------*/
1632static int
1633IFN_Previous_Word(FORM *form)
1634{
1635 FIELD *field = form->current;
1636 FIELD_CELL *bp = Address_Of_Current_Position_In_Buffer(form);
1637 FIELD_CELL *s;
1638 FIELD_CELL *t;
1639 bool again = FALSE;
1640
1641 T((T_CALLED("IFN_Previous_Word(%p)"), form));
1642
1643 /* We really need access to the data, so we have to synchronize */
1644 Synchronize_Buffer(form);
1645
1646 s = After_End_Of_Data(field->buf, (int)(bp - field->buf));
1647 /* s points now right after the last non-blank in the buffer before bp.
1648 If bp was in a word, s equals bp. In this case we must find the last
1649 whitespace in the buffer before bp and repeat the game to really find
1650 the previous word! */
1651 if (s == bp)
1652 again = TRUE;
1653
1654 /* And next call now goes backward to look for the last whitespace
1655 before that, pointing right after this, so it points to the begin
1656 of the previous word.
1657 */
1658 t = After_Last_Whitespace_Character(field->buf, (int)(s - field->buf));
1659#if !FRIENDLY_PREV_NEXT_WORD
1660 if (s == t)
1661 returnCode(E_REQUEST_DENIED);
1662#endif
1663 if (again)
1664 {
1665 /* and do it again, replacing bp by t */
1666 s = After_End_Of_Data(field->buf, (int)(t - field->buf));
1667 t = After_Last_Whitespace_Character(field->buf, (int)(s - field->buf));
1668#if !FRIENDLY_PREV_NEXT_WORD
1669 if (s == t)
1670 returnCode(E_REQUEST_DENIED);
1671#endif
1672 }
1673 Adjust_Cursor_Position(form, t);
1674 returnCode(E_OK);
1675}
1676
1677/*---------------------------------------------------------------------------
1678| Facility : libnform
1679| Function : static int IFN_Beginning_Of_Field(FORM * form)
1680|
1681| Description : Place the cursor at the first non-pad character in
1682| the field.
1683|
1684| Return Values : E_OK - success
1685+--------------------------------------------------------------------------*/
1686static int
1687IFN_Beginning_Of_Field(FORM *form)
1688{
1689 FIELD *field = form->current;
1690
1691 T((T_CALLED("IFN_Beginning_Of_Field(%p)"), form));
1692 Synchronize_Buffer(form);
1693 Adjust_Cursor_Position(form,
1694 Get_Start_Of_Data(field->buf, Buffer_Length(field)));
1695 returnCode(E_OK);
1696}
1697
1698/*---------------------------------------------------------------------------
1699| Facility : libnform
1700| Function : static int IFN_End_Of_Field(FORM * form)
1701|
1702| Description : Place the cursor after the last non-pad character in
1703| the field. If the field occupies the last position in
1704| the buffer, the cursor is positioned on the last
1705| character.
1706|
1707| Return Values : E_OK - success
1708+--------------------------------------------------------------------------*/
1709static int
1710IFN_End_Of_Field(FORM *form)
1711{
1712 FIELD *field = form->current;
1713 FIELD_CELL *pos;
1714
1715 T((T_CALLED("IFN_End_Of_Field(%p)"), form));
1716 Synchronize_Buffer(form);
1717 pos = After_End_Of_Data(field->buf, Buffer_Length(field));
1718 if (pos == (field->buf + Buffer_Length(field)))
1719 pos--;
1720 Adjust_Cursor_Position(form, pos);
1721 returnCode(E_OK);
1722}
1723
1724/*---------------------------------------------------------------------------
1725| Facility : libnform
1726| Function : static int IFN_Beginning_Of_Line(FORM * form)
1727|
1728| Description : Place the cursor on the first non-pad character in
1729| the current line of the field.
1730|
1731| Return Values : E_OK - success
1732+--------------------------------------------------------------------------*/
1733static int
1734IFN_Beginning_Of_Line(FORM *form)
1735{
1736 FIELD *field = form->current;
1737
1738 T((T_CALLED("IFN_Beginning_Of_Line(%p)"), form));
1739 Synchronize_Buffer(form);
1740 Adjust_Cursor_Position(form,
1741 Get_Start_Of_Data(Address_Of_Current_Row_In_Buffer(form),
1742 field->dcols));
1743 returnCode(E_OK);
1744}
1745
1746/*---------------------------------------------------------------------------
1747| Facility : libnform
1748| Function : static int IFN_End_Of_Line(FORM * form)
1749|
1750| Description : Place the cursor after the last non-pad character in the
1751| current line of the field. If the field occupies the
1752| last column in the line, the cursor is positioned on the
1753| last character of the line.
1754|
1755| Return Values : E_OK - success
1756+--------------------------------------------------------------------------*/
1757static int
1758IFN_End_Of_Line(FORM *form)
1759{
1760 FIELD *field = form->current;
1761 FIELD_CELL *pos;
1762 FIELD_CELL *bp;
1763
1764 T((T_CALLED("IFN_End_Of_Line(%p)"), form));
1765 Synchronize_Buffer(form);
1766 bp = Address_Of_Current_Row_In_Buffer(form);
1767 pos = After_End_Of_Data(bp, field->dcols);
1768 if (pos == (bp + field->dcols))
1769 pos--;
1770 Adjust_Cursor_Position(form, pos);
1771 returnCode(E_OK);
1772}
1773
1774/*---------------------------------------------------------------------------
1775| Facility : libnform
1776| Function : static int IFN_Left_Character(FORM * form)
1777|
1778| Description : Move one character to the left in the current line.
1779| This doesn't cycle.
1780|
1781| Return Values : E_OK - success
1782| E_REQUEST_DENIED - already in first column
1783+--------------------------------------------------------------------------*/
1784static int
1785IFN_Left_Character(FORM *form)
1786{
1787 int amount = myWCWIDTH(form->w, form->currow, form->curcol - 1);
1788 int oldcol = form->curcol;
1789
1790 T((T_CALLED("IFN_Left_Character(%p)"), form));
1791 if ((form->curcol -= amount) < 0)
1792 {
1793 form->curcol = oldcol;
1794 returnCode(E_REQUEST_DENIED);
1795 }
1796 returnCode(E_OK);
1797}
1798
1799/*---------------------------------------------------------------------------
1800| Facility : libnform
1801| Function : static int IFN_Right_Character(FORM * form)
1802|
1803| Description : Move one character to the right in the current line.
1804| This doesn't cycle.
1805|
1806| Return Values : E_OK - success
1807| E_REQUEST_DENIED - already in last column
1808+--------------------------------------------------------------------------*/
1809static int
1810IFN_Right_Character(FORM *form)
1811{
1812 int amount = myWCWIDTH(form->w, form->currow, form->curcol);
1813 int oldcol = form->curcol;
1814
1815 T((T_CALLED("IFN_Right_Character(%p)"), form));
1816 if ((form->curcol += amount) >= form->current->dcols)
1817 {
1818#if GROW_IF_NAVIGATE
1819 FIELD *field = form->current;
1820
1821 if (Single_Line_Field(field) && Field_Grown(field, 1))
1822 returnCode(E_OK);
1823#endif
1824 form->curcol = oldcol;
1825 returnCode(E_REQUEST_DENIED);
1826 }
1827 returnCode(E_OK);
1828}
1829
1830/*---------------------------------------------------------------------------
1831| Facility : libnform
1832| Function : static int IFN_Up_Character(FORM * form)
1833|
1834| Description : Move one line up. This doesn't cycle through the lines
1835| of the field.
1836|
1837| Return Values : E_OK - success
1838| E_REQUEST_DENIED - already in last column
1839+--------------------------------------------------------------------------*/
1840static int
1841IFN_Up_Character(FORM *form)
1842{
1843 T((T_CALLED("IFN_Up_Character(%p)"), form));
1844 if ((--(form->currow)) < 0)
1845 {
1846 form->currow++;
1847 returnCode(E_REQUEST_DENIED);
1848 }
1849 returnCode(E_OK);
1850}
1851
1852/*---------------------------------------------------------------------------
1853| Facility : libnform
1854| Function : static int IFN_Down_Character(FORM * form)
1855|
1856| Description : Move one line down. This doesn't cycle through the
1857| lines of the field.
1858|
1859| Return Values : E_OK - success
1860| E_REQUEST_DENIED - already in last column
1861+--------------------------------------------------------------------------*/
1862static int
1863IFN_Down_Character(FORM *form)
1864{
1865 FIELD *field = form->current;
1866
1867 T((T_CALLED("IFN_Down_Character(%p)"), form));
1868 if ((++(form->currow)) == field->drows)
1869 {
1870#if GROW_IF_NAVIGATE
1871 if (!Single_Line_Field(field) && Field_Grown(field, 1))
1872 returnCode(E_OK);
1873#endif
1874 --(form->currow);
1875 returnCode(E_REQUEST_DENIED);
1876 }
1877 returnCode(E_OK);
1878}
1879/*----------------------------------------------------------------------------
1880 END of Intra-Field Navigation routines
1881 --------------------------------------------------------------------------*/
1882
1883/*----------------------------------------------------------------------------
1884 Vertical scrolling helper routines
1885 --------------------------------------------------------------------------*/
1886
1887/*---------------------------------------------------------------------------
1888| Facility : libnform
1889| Function : static int VSC_Generic(FORM *form, int nlines)
1890|
1891| Description : Scroll multi-line field forward (nlines>0) or
1892| backward (nlines<0) this many lines.
1893|
1894| Return Values : E_OK - success
1895| E_REQUEST_DENIED - can't scroll
1896+--------------------------------------------------------------------------*/
1897static int
1898VSC_Generic(FORM *form, int nlines)
1899{
1900 FIELD *field = form->current;
1901 int res = E_REQUEST_DENIED;
1902 int rows_to_go = (nlines > 0 ? nlines : -nlines);
1903
1904 if (nlines > 0)
1905 {
1906 if ((rows_to_go + form->toprow) > (field->drows - field->rows))
1907 rows_to_go = (field->drows - field->rows - form->toprow);
1908
1909 if (rows_to_go > 0)
1910 {
1911 form->currow += rows_to_go;
1912 form->toprow += rows_to_go;
1913 res = E_OK;
1914 }
1915 }
1916 else
1917 {
1918 if (rows_to_go > form->toprow)
1919 rows_to_go = form->toprow;
1920
1921 if (rows_to_go > 0)
1922 {
1923 form->currow -= rows_to_go;
1924 form->toprow -= rows_to_go;
1925 res = E_OK;
1926 }
1927 }
1928 return (res);
1929}
1930/*----------------------------------------------------------------------------
1931 End of Vertical scrolling helper routines
1932 --------------------------------------------------------------------------*/
1933
1934/*----------------------------------------------------------------------------
1935 Vertical scrolling routines
1936 --------------------------------------------------------------------------*/
1937
1938/*---------------------------------------------------------------------------
1939| Facility : libnform
1940| Function : static int Vertical_Scrolling(
1941| int (* const fct) (FORM *),
1942| FORM * form)
1943|
1944| Description : Performs the generic vertical scrolling routines.
1945| This has to check for a multi-line field and to set
1946| the _NEWTOP flag if scrolling really occurred.
1947|
1948| Return Values : Propagated error code from low-level driver calls
1949+--------------------------------------------------------------------------*/
1950static int
1951Vertical_Scrolling(int (*const fct) (FORM *), FORM *form)
1952{
1953 int res = E_REQUEST_DENIED;
1954
1955 if (!Single_Line_Field(form->current))
1956 {
1957 res = fct(form);
1958 if (res == E_OK)
1959 form->current->status |= _NEWTOP;
1960 }
1961 return (res);
1962}
1963
1964/*---------------------------------------------------------------------------
1965| Facility : libnform
1966| Function : static int VSC_Scroll_Line_Forward(FORM * form)
1967|
1968| Description : Scroll multi-line field forward a line
1969|
1970| Return Values : E_OK - success
1971| E_REQUEST_DENIED - no data ahead
1972+--------------------------------------------------------------------------*/
1973static int
1974VSC_Scroll_Line_Forward(FORM *form)
1975{
1976 T((T_CALLED("VSC_Scroll_Line_Forward(%p)"), form));
1977 returnCode(VSC_Generic(form, 1));
1978}
1979
1980/*---------------------------------------------------------------------------
1981| Facility : libnform
1982| Function : static int VSC_Scroll_Line_Backward(FORM * form)
1983|
1984| Description : Scroll multi-line field backward a line
1985|
1986| Return Values : E_OK - success
1987| E_REQUEST_DENIED - no data behind
1988+--------------------------------------------------------------------------*/
1989static int
1990VSC_Scroll_Line_Backward(FORM *form)
1991{
1992 T((T_CALLED("VSC_Scroll_Line_Backward(%p)"), form));
1993 returnCode(VSC_Generic(form, -1));
1994}
1995
1996/*---------------------------------------------------------------------------
1997| Facility : libnform
1998| Function : static int VSC_Scroll_Page_Forward(FORM * form)
1999|
2000| Description : Scroll a multi-line field forward a page
2001|
2002| Return Values : E_OK - success
2003| E_REQUEST_DENIED - no data ahead
2004+--------------------------------------------------------------------------*/
2005static int
2006VSC_Scroll_Page_Forward(FORM *form)
2007{
2008 T((T_CALLED("VSC_Scroll_Page_Forward(%p)"), form));
2009 returnCode(VSC_Generic(form, form->current->rows));
2010}
2011
2012/*---------------------------------------------------------------------------
2013| Facility : libnform
2014| Function : static int VSC_Scroll_Half_Page_Forward(FORM * form)
2015|
2016| Description : Scroll a multi-line field forward half a page
2017|
2018| Return Values : E_OK - success
2019| E_REQUEST_DENIED - no data ahead
2020+--------------------------------------------------------------------------*/
2021static int
2022VSC_Scroll_Half_Page_Forward(FORM *form)
2023{
2024 T((T_CALLED("VSC_Scroll_Half_Page_Forward(%p)"), form));
2025 returnCode(VSC_Generic(form, (form->current->rows + 1) / 2));
2026}
2027
2028/*---------------------------------------------------------------------------
2029| Facility : libnform
2030| Function : static int VSC_Scroll_Page_Backward(FORM * form)
2031|
2032| Description : Scroll a multi-line field backward a page
2033|
2034| Return Values : E_OK - success
2035| E_REQUEST_DENIED - no data behind
2036+--------------------------------------------------------------------------*/
2037static int
2038VSC_Scroll_Page_Backward(FORM *form)
2039{
2040 T((T_CALLED("VSC_Scroll_Page_Backward(%p)"), form));
2041 returnCode(VSC_Generic(form, -(form->current->rows)));
2042}
2043
2044/*---------------------------------------------------------------------------
2045| Facility : libnform
2046| Function : static int VSC_Scroll_Half_Page_Backward(FORM * form)
2047|
2048| Description : Scroll a multi-line field backward half a page
2049|
2050| Return Values : E_OK - success
2051| E_REQUEST_DENIED - no data behind
2052+--------------------------------------------------------------------------*/
2053static int
2054VSC_Scroll_Half_Page_Backward(FORM *form)
2055{
2056 T((T_CALLED("VSC_Scroll_Half_Page_Backward(%p)"), form));
2057 returnCode(VSC_Generic(form, -((form->current->rows + 1) / 2)));
2058}
2059/*----------------------------------------------------------------------------
2060 End of Vertical scrolling routines
2061 --------------------------------------------------------------------------*/
2062
2063/*----------------------------------------------------------------------------
2064 Horizontal scrolling helper routines
2065 --------------------------------------------------------------------------*/
2066
2067/*---------------------------------------------------------------------------
2068| Facility : libnform
2069| Function : static int HSC_Generic(FORM *form, int ncolumns)
2070|
2071| Description : Scroll single-line field forward (ncolumns>0) or
2072| backward (ncolumns<0) this many columns.
2073|
2074| Return Values : E_OK - success
2075| E_REQUEST_DENIED - can't scroll
2076+--------------------------------------------------------------------------*/
2077static int
2078HSC_Generic(FORM *form, int ncolumns)
2079{
2080 FIELD *field = form->current;
2081 int res = E_REQUEST_DENIED;
2082 int cols_to_go = (ncolumns > 0 ? ncolumns : -ncolumns);
2083
2084 if (ncolumns > 0)
2085 {
2086 if ((cols_to_go + form->begincol) > (field->dcols - field->cols))
2087 cols_to_go = field->dcols - field->cols - form->begincol;
2088
2089 if (cols_to_go > 0)
2090 {
2091 form->curcol += cols_to_go;
2092 form->begincol += cols_to_go;
2093 res = E_OK;
2094 }
2095 }
2096 else
2097 {
2098 if (cols_to_go > form->begincol)
2099 cols_to_go = form->begincol;
2100
2101 if (cols_to_go > 0)
2102 {
2103 form->curcol -= cols_to_go;
2104 form->begincol -= cols_to_go;
2105 res = E_OK;
2106 }
2107 }
2108 return (res);
2109}
2110/*----------------------------------------------------------------------------
2111 End of Horizontal scrolling helper routines
2112 --------------------------------------------------------------------------*/
2113
2114/*----------------------------------------------------------------------------
2115 Horizontal scrolling routines
2116 --------------------------------------------------------------------------*/
2117
2118/*---------------------------------------------------------------------------
2119| Facility : libnform
2120| Function : static int Horizontal_Scrolling(
2121| int (* const fct) (FORM *),
2122| FORM * form)
2123|
2124| Description : Performs the generic horizontal scrolling routines.
2125| This has to check for a single-line field.
2126|
2127| Return Values : Propagated error code from low-level driver calls
2128+--------------------------------------------------------------------------*/
2129static int
2130Horizontal_Scrolling(int (*const fct) (FORM *), FORM *form)
2131{
2132 if (Single_Line_Field(form->current))
2133 return fct(form);
2134 else
2135 return (E_REQUEST_DENIED);
2136}
2137
2138/*---------------------------------------------------------------------------
2139| Facility : libnform
2140| Function : static int HSC_Scroll_Char_Forward(FORM * form)
2141|
2142| Description : Scroll single-line field forward a character
2143|
2144| Return Values : E_OK - success
2145| E_REQUEST_DENIED - no data ahead
2146+--------------------------------------------------------------------------*/
2147static int
2148HSC_Scroll_Char_Forward(FORM *form)
2149{
2150 T((T_CALLED("HSC_Scroll_Char_Forward(%p)"), form));
2151 returnCode(HSC_Generic(form, 1));
2152}
2153
2154/*---------------------------------------------------------------------------
2155| Facility : libnform
2156| Function : static int HSC_Scroll_Char_Backward(FORM * form)
2157|
2158| Description : Scroll single-line field backward a character
2159|
2160| Return Values : E_OK - success
2161| E_REQUEST_DENIED - no data behind
2162+--------------------------------------------------------------------------*/
2163static int
2164HSC_Scroll_Char_Backward(FORM *form)
2165{
2166 T((T_CALLED("HSC_Scroll_Char_Backward(%p)"), form));
2167 returnCode(HSC_Generic(form, -1));
2168}
2169
2170/*---------------------------------------------------------------------------
2171| Facility : libnform
2172| Function : static int HSC_Horizontal_Line_Forward(FORM* form)
2173|
2174| Description : Scroll single-line field forward a line
2175|
2176| Return Values : E_OK - success
2177| E_REQUEST_DENIED - no data ahead
2178+--------------------------------------------------------------------------*/
2179static int
2180HSC_Horizontal_Line_Forward(FORM *form)
2181{
2182 T((T_CALLED("HSC_Horizontal_Line_Forward(%p)"), form));
2183 returnCode(HSC_Generic(form, form->current->cols));
2184}
2185
2186/*---------------------------------------------------------------------------
2187| Facility : libnform
2188| Function : static int HSC_Horizontal_Half_Line_Forward(FORM* form)
2189|
2190| Description : Scroll single-line field forward half a line
2191|
2192| Return Values : E_OK - success
2193| E_REQUEST_DENIED - no data ahead
2194+--------------------------------------------------------------------------*/
2195static int
2196HSC_Horizontal_Half_Line_Forward(FORM *form)
2197{
2198 T((T_CALLED("HSC_Horizontal_Half_Line_Forward(%p)"), form));
2199 returnCode(HSC_Generic(form, (form->current->cols + 1) / 2));
2200}
2201
2202/*---------------------------------------------------------------------------
2203| Facility : libnform
2204| Function : static int HSC_Horizontal_Line_Backward(FORM* form)
2205|
2206| Description : Scroll single-line field backward a line
2207|
2208| Return Values : E_OK - success
2209| E_REQUEST_DENIED - no data behind
2210+--------------------------------------------------------------------------*/
2211static int
2212HSC_Horizontal_Line_Backward(FORM *form)
2213{
2214 T((T_CALLED("HSC_Horizontal_Line_Backward(%p)"), form));
2215 returnCode(HSC_Generic(form, -(form->current->cols)));
2216}
2217
2218/*---------------------------------------------------------------------------
2219| Facility : libnform
2220| Function : static int HSC_Horizontal_Half_Line_Backward(FORM* form)
2221|
2222| Description : Scroll single-line field backward half a line
2223|
2224| Return Values : E_OK - success
2225| E_REQUEST_DENIED - no data behind
2226+--------------------------------------------------------------------------*/
2227static int
2228HSC_Horizontal_Half_Line_Backward(FORM *form)
2229{
2230 T((T_CALLED("HSC_Horizontal_Half_Line_Backward(%p)"), form));
2231 returnCode(HSC_Generic(form, -((form->current->cols + 1) / 2)));
2232}
2233
2234/*----------------------------------------------------------------------------
2235 End of Horizontal scrolling routines
2236 --------------------------------------------------------------------------*/
2237
2238/*----------------------------------------------------------------------------
2239 Helper routines for Field Editing
2240 --------------------------------------------------------------------------*/
2241
2242/*---------------------------------------------------------------------------
2243| Facility : libnform
2244| Function : static bool Is_There_Room_For_A_Line(FORM * form)
2245|
2246| Description : Check whether or not there is enough room in the
2247| buffer to enter a whole line.
2248|
2249| Return Values : TRUE - there is enough space
2250| FALSE - there is not enough space
2251+--------------------------------------------------------------------------*/
2252NCURSES_INLINE static bool
2253Is_There_Room_For_A_Line(FORM *form)
2254{
2255 FIELD *field = form->current;
2256 FIELD_CELL *begin_of_last_line, *s;
2257
2258 Synchronize_Buffer(form);
2259 begin_of_last_line = Address_Of_Row_In_Buffer(field, (field->drows - 1));
2260 s = After_End_Of_Data(begin_of_last_line, field->dcols);
2261 return ((s == begin_of_last_line) ? TRUE : FALSE);
2262}
2263
2264/*---------------------------------------------------------------------------
2265| Facility : libnform
2266| Function : static bool Is_There_Room_For_A_Char_In_Line(FORM * form)
2267|
2268| Description : Checks whether or not there is room for a new character
2269| in the current line.
2270|
2271| Return Values : TRUE - there is room
2272| FALSE - there is not enough room (line full)
2273+--------------------------------------------------------------------------*/
2274NCURSES_INLINE static bool
2275Is_There_Room_For_A_Char_In_Line(FORM *form)
2276{
2277 int last_char_in_line;
2278
2279 wmove(form->w, form->currow, form->current->dcols - 1);
2280 last_char_in_line = (int)(winch(form->w) & A_CHARTEXT);
2281 wmove(form->w, form->currow, form->curcol);
2282 return (((last_char_in_line == form->current->pad) ||
2283 is_blank(last_char_in_line)) ? TRUE : FALSE);
2284}
2285
2286#define There_Is_No_Room_For_A_Char_In_Line(f) \
2287 !Is_There_Room_For_A_Char_In_Line(f)
2288
2289/*---------------------------------------------------------------------------
2290| Facility : libnform
2291| Function : static int Insert_String(
2292| FORM * form,
2293| int row,
2294| char *txt,
2295| int len )
2296|
2297| Description : Insert the 'len' characters beginning at pointer 'txt'
2298| into the 'row' of the 'form'. The insertion occurs
2299| on the beginning of the row, all other characters are
2300| moved to the right. After the text a pad character will
2301| be inserted to separate the text from the rest. If
2302| necessary the insertion moves characters on the next
2303| line to make place for the requested insertion string.
2304|
2305| Return Values : E_OK - success
2306| E_REQUEST_DENIED -
2307| E_SYSTEM_ERROR - system error
2308+--------------------------------------------------------------------------*/
2309static int
2310Insert_String(FORM *form, int row, FIELD_CELL *txt, int len)
2311{
2312 FIELD *field = form->current;
2313 FIELD_CELL *bp = Address_Of_Row_In_Buffer(field, row);
2314 int datalen = (int)(After_End_Of_Data(bp, field->dcols) - bp);
2315 int freelen = field->dcols - datalen;
2316 int requiredlen = len + 1;
2317 FIELD_CELL *split;
2318 int result = E_REQUEST_DENIED;
2319
2320 if (freelen >= requiredlen)
2321 {
2322 wmove(form->w, row, 0);
2323 myINSNSTR(form->w, txt, len);
2324 wmove(form->w, row, len);
2325 myINSNSTR(form->w, &myBLANK, 1);
2326 return E_OK;
2327 }
2328 else
2329 {
2330 /* we have to move characters on the next line. If we are on the
2331 last line this may work, if the field is growable */
2332 if ((row == (field->drows - 1)) && Growable(field))
2333 {
2334 if (!Field_Grown(field, 1))
2335 return (E_SYSTEM_ERROR);
2336 /* !!!Side-Effect : might be changed due to growth!!! */
2337 bp = Address_Of_Row_In_Buffer(field, row);
2338 }
2339
2340 if (row < (field->drows - 1))
2341 {
2342 split =
2343 After_Last_Whitespace_Character(bp,
2344 (int)(Get_Start_Of_Data(bp
2345 + field->dcols
2346 - requiredlen,
2347 requiredlen)
2348 - bp));
2349 /* split points now to the first character of the portion of the
2350 line that must be moved to the next line */
2351 datalen = (int)(split - bp); /* + freelen has to stay on this line */
2352 freelen = field->dcols - (datalen + freelen); /* for the next line */
2353
2354 if ((result = Insert_String(form, row + 1, split, freelen)) == E_OK)
2355 {
2356 wmove(form->w, row, datalen);
2357 wclrtoeol(form->w);
2358 wmove(form->w, row, 0);
2359 myINSNSTR(form->w, txt, len);
2360 wmove(form->w, row, len);
2361 myINSNSTR(form->w, &myBLANK, 1);
2362 return E_OK;
2363 }
2364 }
2365 return (result);
2366 }
2367}
2368
2369/*---------------------------------------------------------------------------
2370| Facility : libnform
2371| Function : static int Wrapping_Not_Necessary_Or_Wrapping_Ok(
2372| FORM * form)
2373|
2374| Description : If a character has been entered into a field, it may
2375| be that wrapping has to occur. This routine checks
2376| whether or not wrapping is required and if so, performs
2377| the wrapping.
2378|
2379| Return Values : E_OK - no wrapping required or wrapping
2380| was successful
2381| E_REQUEST_DENIED -
2382| E_SYSTEM_ERROR - some system error
2383+--------------------------------------------------------------------------*/
2384static int
2385Wrapping_Not_Necessary_Or_Wrapping_Ok(FORM *form)
2386{
2387 FIELD *field = form->current;
2388 int result = E_REQUEST_DENIED;
2389 bool Last_Row = ((field->drows - 1) == form->currow);
2390
2391 if ((field->opts & O_WRAP) && /* wrapping wanted */
2392 (!Single_Line_Field(field)) && /* must be multi-line */
2393 (There_Is_No_Room_For_A_Char_In_Line(form)) && /* line is full */
2394 (!Last_Row || Growable(field))) /* there are more lines */
2395 {
2396 FIELD_CELL *bp;
2397 FIELD_CELL *split;
2398 int chars_to_be_wrapped;
2399 int chars_to_remain_on_line;
2400
2401 if (Last_Row)
2402 {
2403 /* the above logic already ensures, that in this case the field
2404 is growable */
2405 if (!Field_Grown(field, 1))
2406 return E_SYSTEM_ERROR;
2407 }
2408 bp = Address_Of_Current_Row_In_Buffer(form);
2409 Window_To_Buffer(form->w, field);
2410 split = After_Last_Whitespace_Character(bp, field->dcols);
2411 /* split points to the first character of the sequence to be brought
2412 on the next line */
2413 chars_to_remain_on_line = (int)(split - bp);
2414 chars_to_be_wrapped = field->dcols - chars_to_remain_on_line;
2415 if (chars_to_remain_on_line > 0)
2416 {
2417 if ((result = Insert_String(form, form->currow + 1, split,
2418 chars_to_be_wrapped)) == E_OK)
2419 {
2420 wmove(form->w, form->currow, chars_to_remain_on_line);
2421 wclrtoeol(form->w);
2422 if (form->curcol >= chars_to_remain_on_line)
2423 {
2424 form->currow++;
2425 form->curcol -= chars_to_remain_on_line;
2426 }
2427 return E_OK;
2428 }
2429 }
2430 else
2431 return E_OK;
2432 if (result != E_OK)
2433 {
2434 DeleteChar(form);
2435 Window_To_Buffer(form->w, field);
2436 result = E_REQUEST_DENIED;
2437 }
2438 }
2439 else
2440 result = E_OK; /* wrapping was not necessary */
2441 return (result);
2442}
2443
2444/*----------------------------------------------------------------------------
2445 Field Editing routines
2446 --------------------------------------------------------------------------*/
2447
2448/*---------------------------------------------------------------------------
2449| Facility : libnform
2450| Function : static int Field_Editing(
2451| int (* const fct) (FORM *),
2452| FORM * form)
2453|
2454| Description : Generic routine for field editing requests. The driver
2455| routines are only called for editable fields, the
2456| _WINDOW_MODIFIED flag is set if editing occurred.
2457| This is somewhat special due to the overload semantics
2458| of the NEW_LINE and DEL_PREV requests.
2459|
2460| Return Values : Error code from low level drivers.
2461+--------------------------------------------------------------------------*/
2462static int
2463Field_Editing(int (*const fct) (FORM *), FORM *form)
2464{
2465 int res = E_REQUEST_DENIED;
2466
2467 /* We have to deal here with the specific case of the overloaded
2468 behavior of New_Line and Delete_Previous requests.
2469 They may end up in navigational requests if we are on the first
2470 character in a field. But navigation is also allowed on non-
2471 editable fields.
2472 */
2473 if ((fct == FE_Delete_Previous) &&
2474 (form->opts & O_BS_OVERLOAD) &&
2475 First_Position_In_Current_Field(form))
2476 {
2477 res = Inter_Field_Navigation(FN_Previous_Field, form);
2478 }
2479 else
2480 {
2481 if (fct == FE_New_Line)
2482 {
2483 if ((form->opts & O_NL_OVERLOAD) &&
2484 First_Position_In_Current_Field(form))
2485 {
2486 res = Inter_Field_Navigation(FN_Next_Field, form);
2487 }
2488 else
2489 /* FE_New_Line deals itself with the _WINDOW_MODIFIED flag */
2490 res = fct(form);
2491 }
2492 else
2493 {
2494 /* From now on, everything must be editable */
2495 if (form->current->opts & O_EDIT)
2496 {
2497 res = fct(form);
2498 if (res == E_OK)
2499 form->status |= _WINDOW_MODIFIED;
2500 }
2501 }
2502 }
2503 return res;
2504}
2505
2506/*---------------------------------------------------------------------------
2507| Facility : libnform
2508| Function : static int FE_New_Line(FORM * form)
2509|
2510| Description : Perform a new line request. This is rather complex
2511| compared to other routines in this code due to the
2512| rather difficult to understand description in the
2513| manuals.
2514|
2515| Return Values : E_OK - success
2516| E_REQUEST_DENIED - new line not allowed
2517| E_SYSTEM_ERROR - system error
2518+--------------------------------------------------------------------------*/
2519static int
2520FE_New_Line(FORM *form)
2521{
2522 FIELD *field = form->current;
2523 FIELD_CELL *bp, *t;
2524 bool Last_Row = ((field->drows - 1) == form->currow);
2525
2526 T((T_CALLED("FE_New_Line(%p)"), form));
2527 if (form->status & _OVLMODE)
2528 {
2529 if (Last_Row &&
2530 (!(Growable(field) && !Single_Line_Field(field))))
2531 {
2532 if (!(form->opts & O_NL_OVERLOAD))
2533 returnCode(E_REQUEST_DENIED);
2534 wmove(form->w, form->currow, form->curcol);
2535 wclrtoeol(form->w);
2536 /* we have to set this here, although it is also
2537 handled in the generic routine. The reason is,
2538 that FN_Next_Field may fail, but the form is
2539 definitively changed */
2540 form->status |= _WINDOW_MODIFIED;
2541 returnCode(Inter_Field_Navigation(FN_Next_Field, form));
2542 }
2543 else
2544 {
2545 if (Last_Row && !Field_Grown(field, 1))
2546 {
2547 /* N.B.: due to the logic in the 'if', LastRow==TRUE
2548 means here that the field is growable and not
2549 a single-line field */
2550 returnCode(E_SYSTEM_ERROR);
2551 }
2552 wmove(form->w, form->currow, form->curcol);
2553 wclrtoeol(form->w);
2554 form->currow++;
2555 form->curcol = 0;
2556 form->status |= _WINDOW_MODIFIED;
2557 returnCode(E_OK);
2558 }
2559 }
2560 else
2561 {
2562 /* Insert Mode */
2563 if (Last_Row &&
2564 !(Growable(field) && !Single_Line_Field(field)))
2565 {
2566 if (!(form->opts & O_NL_OVERLOAD))
2567 returnCode(E_REQUEST_DENIED);
2568 returnCode(Inter_Field_Navigation(FN_Next_Field, form));
2569 }
2570 else
2571 {
2572 bool May_Do_It = !Last_Row && Is_There_Room_For_A_Line(form);
2573
2574 if (!(May_Do_It || Growable(field)))
2575 returnCode(E_REQUEST_DENIED);
2576 if (!May_Do_It && !Field_Grown(field, 1))
2577 returnCode(E_SYSTEM_ERROR);
2578
2579 bp = Address_Of_Current_Position_In_Buffer(form);
2580 t = After_End_Of_Data(bp, field->dcols - form->curcol);
2581 wmove(form->w, form->currow, form->curcol);
2582 wclrtoeol(form->w);
2583 form->currow++;
2584 form->curcol = 0;
2585 wmove(form->w, form->currow, form->curcol);
2586 winsertln(form->w);
2587 myADDNSTR(form->w, bp, (int)(t - bp));
2588 form->status |= _WINDOW_MODIFIED;
2589 returnCode(E_OK);
2590 }
2591 }
2592}
2593
2594/*---------------------------------------------------------------------------
2595| Facility : libnform
2596| Function : static int FE_Insert_Character(FORM * form)
2597|
2598| Description : Insert blank character at the cursor position
2599|
2600| Return Values : E_OK
2601| E_REQUEST_DENIED
2602+--------------------------------------------------------------------------*/
2603static int
2604FE_Insert_Character(FORM *form)
2605{
2606 FIELD *field = form->current;
2607 int result = E_REQUEST_DENIED;
2608
2609 T((T_CALLED("FE_Insert_Character(%p)"), form));
2610 if (Check_Char(field->type, (int)C_BLANK, (TypeArgument *)(field->arg)))
2611 {
2612 bool There_Is_Room = Is_There_Room_For_A_Char_In_Line(form);
2613
2614 if (There_Is_Room ||
2615 ((Single_Line_Field(field) && Growable(field))))
2616 {
2617 if (!There_Is_Room && !Field_Grown(field, 1))
2618 result = E_SYSTEM_ERROR;
2619 else
2620 {
2621 winsch(form->w, (chtype)C_BLANK);
2622 result = Wrapping_Not_Necessary_Or_Wrapping_Ok(form);
2623 }
2624 }
2625 }
2626 returnCode(result);
2627}
2628
2629/*---------------------------------------------------------------------------
2630| Facility : libnform
2631| Function : static int FE_Insert_Line(FORM * form)
2632|
2633| Description : Insert a blank line at the cursor position
2634|
2635| Return Values : E_OK - success
2636| E_REQUEST_DENIED - line can not be inserted
2637+--------------------------------------------------------------------------*/
2638static int
2639FE_Insert_Line(FORM *form)
2640{
2641 FIELD *field = form->current;
2642 int result = E_REQUEST_DENIED;
2643
2644 T((T_CALLED("FE_Insert_Line(%p)"), form));
2645 if (Check_Char(field->type, (int)C_BLANK, (TypeArgument *)(field->arg)))
2646 {
2647 bool Maybe_Done = (form->currow != (field->drows - 1)) &&
2648 Is_There_Room_For_A_Line(form);
2649
2650 if (!Single_Line_Field(field) &&
2651 (Maybe_Done || Growable(field)))
2652 {
2653 if (!Maybe_Done && !Field_Grown(field, 1))
2654 result = E_SYSTEM_ERROR;
2655 else
2656 {
2657 form->curcol = 0;
2658 winsertln(form->w);
2659 result = E_OK;
2660 }
2661 }
2662 }
2663 returnCode(result);
2664}
2665
2666/*---------------------------------------------------------------------------
2667| Facility : libnform
2668| Function : static int FE_Delete_Character(FORM * form)
2669|
2670| Description : Delete character at the cursor position
2671|
2672| Return Values : E_OK - success
2673+--------------------------------------------------------------------------*/
2674static int
2675FE_Delete_Character(FORM *form)
2676{
2677 T((T_CALLED("FE_Delete_Character(%p)"), form));
2678 DeleteChar(form);
2679 returnCode(E_OK);
2680}
2681
2682/*---------------------------------------------------------------------------
2683| Facility : libnform
2684| Function : static int FE_Delete_Previous(FORM * form)
2685|
2686| Description : Delete character before cursor. Again this is a rather
2687| difficult piece compared to others due to the overloading
2688| semantics of backspace.
2689| N.B.: The case of overloaded BS on first field position
2690| is already handled in the generic routine.
2691|
2692| Return Values : E_OK - success
2693| E_REQUEST_DENIED - Character can't be deleted
2694+--------------------------------------------------------------------------*/
2695static int
2696FE_Delete_Previous(FORM *form)
2697{
2698 FIELD *field = form->current;
2699
2700 T((T_CALLED("FE_Delete_Previous(%p)"), form));
2701 if (First_Position_In_Current_Field(form))
2702 returnCode(E_REQUEST_DENIED);
2703
2704 if ((--(form->curcol)) < 0)
2705 {
2706 FIELD_CELL *this_line, *prev_line, *prev_end, *this_end;
2707 int this_row = form->currow;
2708
2709 form->curcol++;
2710 if (form->status & _OVLMODE)
2711 returnCode(E_REQUEST_DENIED);
2712
2713 prev_line = Address_Of_Row_In_Buffer(field, (form->currow - 1));
2714 this_line = Address_Of_Row_In_Buffer(field, (form->currow));
2715 Synchronize_Buffer(form);
2716 prev_end = After_End_Of_Data(prev_line, field->dcols);
2717 this_end = After_End_Of_Data(this_line, field->dcols);
2718 if ((int)(this_end - this_line) >
2719 (field->cols - (int)(prev_end - prev_line)))
2720 returnCode(E_REQUEST_DENIED);
2721 wmove(form->w, form->currow, form->curcol);
2722 wdeleteln(form->w);
2723 Adjust_Cursor_Position(form, prev_end);
2724 /*
2725 * If we did not really move to the previous line, help the user a
2726 * little. It is however a little inconsistent. Normally, when
2727 * backspacing around the point where text wraps to a new line in a
2728 * multi-line form, we absorb one keystroke for the wrapping point. That
2729 * is consistent with SVr4 forms. However, SVr4 does not allow typing
2730 * into the last column of the field, and requires the user to enter a
2731 * newline to move to the next line. Therefore it can consistently eat
2732 * that keystroke. Since ncurses allows the last column, it wraps
2733 * automatically (given the proper options). But we cannot eat the
2734 * keystroke to back over the wrapping point, since that would put the
2735 * cursor past the end of the form field. In this case, just delete the
2736 * character at the end of the field.
2737 */
2738 if (form->currow == this_row && this_row > 0)
2739 {
2740 form->currow -= 1;
2741 form->curcol = field->dcols - 1;
2742 DeleteChar(form);
2743 }
2744 else
2745 {
2746 wmove(form->w, form->currow, form->curcol);
2747 myADDNSTR(form->w, this_line, (int)(this_end - this_line));
2748 }
2749 }
2750 else
2751 {
2752 DeleteChar(form);
2753 }
2754 returnCode(E_OK);
2755}
2756
2757/*---------------------------------------------------------------------------
2758| Facility : libnform
2759| Function : static int FE_Delete_Line(FORM * form)
2760|
2761| Description : Delete line at cursor position.
2762|
2763| Return Values : E_OK - success
2764+--------------------------------------------------------------------------*/
2765static int
2766FE_Delete_Line(FORM *form)
2767{
2768 T((T_CALLED("FE_Delete_Line(%p)"), form));
2769 form->curcol = 0;
2770 wdeleteln(form->w);
2771 returnCode(E_OK);
2772}
2773
2774/*---------------------------------------------------------------------------
2775| Facility : libnform
2776| Function : static int FE_Delete_Word(FORM * form)
2777|
2778| Description : Delete word at cursor position
2779|
2780| Return Values : E_OK - success
2781| E_REQUEST_DENIED - failure
2782+--------------------------------------------------------------------------*/
2783static int
2784FE_Delete_Word(FORM *form)
2785{
2786 FIELD *field = form->current;
2787 FIELD_CELL *bp = Address_Of_Current_Row_In_Buffer(form);
2788 FIELD_CELL *ep = bp + field->dcols;
2789 FIELD_CELL *cp = bp + form->curcol;
2790 FIELD_CELL *s;
2791
2792 T((T_CALLED("FE_Delete_Word(%p)"), form));
2793 Synchronize_Buffer(form);
2794 if (ISBLANK(*cp))
2795 returnCode(E_REQUEST_DENIED); /* not in word */
2796
2797 /* move cursor to begin of word and erase to end of screen-line */
2798 Adjust_Cursor_Position(form,
2799 After_Last_Whitespace_Character(bp, form->curcol));
2800 wmove(form->w, form->currow, form->curcol);
2801 wclrtoeol(form->w);
2802
2803 /* skip over word in buffer */
2804 s = Get_First_Whitespace_Character(cp, (int)(ep - cp));
2805 /* to begin of next word */
2806 s = Get_Start_Of_Data(s, (int)(ep - s));
2807 if ((s != cp) && !ISBLANK(*s))
2808 {
2809 /* copy remaining line to window */
2810 myADDNSTR(form->w, s, (int)(s - After_End_Of_Data(s, (int)(ep - s))));
2811 }
2812 returnCode(E_OK);
2813}
2814
2815/*---------------------------------------------------------------------------
2816| Facility : libnform
2817| Function : static int FE_Clear_To_End_Of_Line(FORM * form)
2818|
2819| Description : Clear to end of current line.
2820|
2821| Return Values : E_OK - success
2822+--------------------------------------------------------------------------*/
2823static int
2824FE_Clear_To_End_Of_Line(FORM *form)
2825{
2826 T((T_CALLED("FE_Clear_To_End_Of_Line(%p)"), form));
2827 wmove(form->w, form->currow, form->curcol);
2828 wclrtoeol(form->w);
2829 returnCode(E_OK);
2830}
2831
2832/*---------------------------------------------------------------------------
2833| Facility : libnform
2834| Function : static int FE_Clear_To_End_Of_Field(FORM * form)
2835|
2836| Description : Clear to end of field.
2837|
2838| Return Values : E_OK - success
2839+--------------------------------------------------------------------------*/
2840static int
2841FE_Clear_To_End_Of_Field(FORM *form)
2842{
2843 T((T_CALLED("FE_Clear_To_End_Of_Field(%p)"), form));
2844 wmove(form->w, form->currow, form->curcol);
2845 wclrtobot(form->w);
2846 returnCode(E_OK);
2847}
2848
2849/*---------------------------------------------------------------------------
2850| Facility : libnform
2851| Function : static int FE_Clear_Field(FORM * form)
2852|
2853| Description : Clear entire field.
2854|
2855| Return Values : E_OK - success
2856+--------------------------------------------------------------------------*/
2857static int
2858FE_Clear_Field(FORM *form)
2859{
2860 T((T_CALLED("FE_Clear_Field(%p)"), form));
2861 form->currow = form->curcol = 0;
2862 werase(form->w);
2863 returnCode(E_OK);
2864}
2865/*----------------------------------------------------------------------------
2866 END of Field Editing routines
2867 --------------------------------------------------------------------------*/
2868
2869/*----------------------------------------------------------------------------
2870 Edit Mode routines
2871 --------------------------------------------------------------------------*/
2872
2873/*---------------------------------------------------------------------------
2874| Facility : libnform
2875| Function : static int EM_Overlay_Mode(FORM * form)
2876|
2877| Description : Switch to overlay mode.
2878|
2879| Return Values : E_OK - success
2880+--------------------------------------------------------------------------*/
2881static int
2882EM_Overlay_Mode(FORM *form)
2883{
2884 T((T_CALLED("EM_Overlay_Mode(%p)"), form));
2885 form->status |= _OVLMODE;
2886 returnCode(E_OK);
2887}
2888
2889/*---------------------------------------------------------------------------
2890| Facility : libnform
2891| Function : static int EM_Insert_Mode(FORM * form)
2892|
2893| Description : Switch to insert mode
2894|
2895| Return Values : E_OK - success
2896+--------------------------------------------------------------------------*/
2897static int
2898EM_Insert_Mode(FORM *form)
2899{
2900 T((T_CALLED("EM_Insert_Mode(%p)"), form));
2901 form->status &= ~_OVLMODE;
2902 returnCode(E_OK);
2903}
2904
2905/*----------------------------------------------------------------------------
2906 END of Edit Mode routines
2907 --------------------------------------------------------------------------*/
2908
2909/*----------------------------------------------------------------------------
2910 Helper routines for Choice Requests
2911 --------------------------------------------------------------------------*/
2912
2913/*---------------------------------------------------------------------------
2914| Facility : libnform
2915| Function : static bool Next_Choice(
2916| FIELDTYPE * typ,
2917| FIELD * field,
2918| TypeArgument *argp)
2919|
2920| Description : Get the next field choice. For linked types this is
2921| done recursively.
2922|
2923| Return Values : TRUE - next choice successfully retrieved
2924| FALSE - couldn't retrieve next choice
2925+--------------------------------------------------------------------------*/
2926static bool
2927Next_Choice(FIELDTYPE *typ, FIELD *field, TypeArgument *argp)
2928{
2929 if (!typ || !(typ->status & _HAS_CHOICE))
2930 return FALSE;
2931
2932 if (typ->status & _LINKED_TYPE)
2933 {
2934 assert(argp);
2935 return (
2936 Next_Choice(typ->left, field, argp->left) ||
2937 Next_Choice(typ->right, field, argp->right));
2938 }
2939 else
2940 {
2941 assert(typ->next);
2942 return typ->next(field, (void *)argp);
2943 }
2944}
2945
2946/*---------------------------------------------------------------------------
2947| Facility : libnform
2948| Function : static bool Previous_Choice(
2949| FIELDTYPE * typ,
2950| FIELD * field,
2951| TypeArgument *argp)
2952|
2953| Description : Get the previous field choice. For linked types this
2954| is done recursively.
2955|
2956| Return Values : TRUE - previous choice successfully retrieved
2957| FALSE - couldn't retrieve previous choice
2958+--------------------------------------------------------------------------*/
2959static bool
2960Previous_Choice(FIELDTYPE *typ, FIELD *field, TypeArgument *argp)
2961{
2962 if (!typ || !(typ->status & _HAS_CHOICE))
2963 return FALSE;
2964
2965 if (typ->status & _LINKED_TYPE)
2966 {
2967 assert(argp);
2968 return (
2969 Previous_Choice(typ->left, field, argp->left) ||
2970 Previous_Choice(typ->right, field, argp->right));
2971 }
2972 else
2973 {
2974 assert(typ->prev);
2975 return typ->prev(field, (void *)argp);
2976 }
2977}
2978/*----------------------------------------------------------------------------
2979 End of Helper routines for Choice Requests
2980 --------------------------------------------------------------------------*/
2981
2982/*----------------------------------------------------------------------------
2983 Routines for Choice Requests
2984 --------------------------------------------------------------------------*/
2985
2986/*---------------------------------------------------------------------------
2987| Facility : libnform
2988| Function : static int CR_Next_Choice(FORM * form)
2989|
2990| Description : Get the next field choice.
2991|
2992| Return Values : E_OK - success
2993| E_REQUEST_DENIED - next choice couldn't be retrieved
2994+--------------------------------------------------------------------------*/
2995static int
2996CR_Next_Choice(FORM *form)
2997{
2998 FIELD *field = form->current;
2999
3000 T((T_CALLED("CR_Next_Choice(%p)"), form));
3001 Synchronize_Buffer(form);
3002 returnCode((Next_Choice(field->type, field, (TypeArgument *)(field->arg)))
3003 ? E_OK
3004 : E_REQUEST_DENIED);
3005}
3006
3007/*---------------------------------------------------------------------------
3008| Facility : libnform
3009| Function : static int CR_Previous_Choice(FORM * form)
3010|
3011| Description : Get the previous field choice.
3012|
3013| Return Values : E_OK - success
3014| E_REQUEST_DENIED - prev. choice couldn't be retrieved
3015+--------------------------------------------------------------------------*/
3016static int
3017CR_Previous_Choice(FORM *form)
3018{
3019 FIELD *field = form->current;
3020
3021 T((T_CALLED("CR_Previous_Choice(%p)"), form));
3022 Synchronize_Buffer(form);
3023 returnCode((Previous_Choice(field->type, field, (TypeArgument *)(field->arg)))
3024 ? E_OK
3025 : E_REQUEST_DENIED);
3026}
3027/*----------------------------------------------------------------------------
3028 End of Routines for Choice Requests
3029 --------------------------------------------------------------------------*/
3030
3031/*----------------------------------------------------------------------------
3032 Helper routines for Field Validations.
3033 --------------------------------------------------------------------------*/
3034
3035/*---------------------------------------------------------------------------
3036| Facility : libnform
3037| Function : static bool Check_Field(
3038| FIELDTYPE * typ,
3039| FIELD * field,
3040| TypeArgument * argp)
3041|
3042| Description : Check the field according to its fieldtype and its
3043| actual arguments. For linked fieldtypes this is done
3044| recursively.
3045|
3046| Return Values : TRUE - field is valid
3047| FALSE - field is invalid.
3048+--------------------------------------------------------------------------*/
3049static bool
3050Check_Field(FIELDTYPE *typ, FIELD *field, TypeArgument *argp)
3051{
3052 if (typ)
3053 {
3054 if (field->opts & O_NULLOK)
3055 {
3056 FIELD_CELL *bp = field->buf;
3057
3058 assert(bp);
3059 while (ISBLANK(*bp))
3060 {
3061 bp++;
3062 }
3063 if (CharOf(*bp) == 0)
3064 return TRUE;
3065 }
3066
3067 if (typ->status & _LINKED_TYPE)
3068 {
3069 assert(argp);
3070 return (
3071 Check_Field(typ->left, field, argp->left) ||
3072 Check_Field(typ->right, field, argp->right));
3073 }
3074 else
3075 {
3076 if (typ->fcheck)
3077 return typ->fcheck(field, (void *)argp);
3078 }
3079 }
3080 return TRUE;
3081}
3082
3083/*---------------------------------------------------------------------------
3084| Facility : libnform
3085| Function : bool _nc_Internal_Validation(FORM * form )
3086|
3087| Description : Validate the current field of the form.
3088|
3089| Return Values : TRUE - field is valid
3090| FALSE - field is invalid
3091+--------------------------------------------------------------------------*/
3092NCURSES_EXPORT(bool)
3093_nc_Internal_Validation(FORM *form)
3094{
3095 FIELD *field;
3096
3097 field = form->current;
3098
3099 Synchronize_Buffer(form);
3100 if ((form->status & _FCHECK_REQUIRED) ||
3101 (!(field->opts & O_PASSOK)))
3102 {
3103 if (!Check_Field(field->type, field, (TypeArgument *)(field->arg)))
3104 return FALSE;
3105 form->status &= ~_FCHECK_REQUIRED;
3106 field->status |= _CHANGED;
3107 Synchronize_Linked_Fields(field);
3108 }
3109 return TRUE;
3110}
3111/*----------------------------------------------------------------------------
3112 End of Helper routines for Field Validations.
3113 --------------------------------------------------------------------------*/
3114
3115/*----------------------------------------------------------------------------
3116 Routines for Field Validation.
3117 --------------------------------------------------------------------------*/
3118
3119/*---------------------------------------------------------------------------
3120| Facility : libnform
3121| Function : static int FV_Validation(FORM * form)
3122|
3123| Description : Validate the current field of the form.
3124|
3125| Return Values : E_OK - field valid
3126| E_INVALID_FIELD - field not valid
3127+--------------------------------------------------------------------------*/
3128static int
3129FV_Validation(FORM *form)
3130{
3131 T((T_CALLED("FV_Validation(%p)"), form));
3132 if (_nc_Internal_Validation(form))
3133 returnCode(E_OK);
3134 else
3135 returnCode(E_INVALID_FIELD);
3136}
3137/*----------------------------------------------------------------------------
3138 End of routines for Field Validation.
3139 --------------------------------------------------------------------------*/
3140
3141/*----------------------------------------------------------------------------
3142 Helper routines for Inter-Field Navigation
3143 --------------------------------------------------------------------------*/
3144
3145/*---------------------------------------------------------------------------
3146| Facility : libnform
3147| Function : static FIELD *Next_Field_On_Page(FIELD * field)
3148|
3149| Description : Get the next field after the given field on the current
3150| page. The order of fields is the one defined by the
3151| fields array. Only visible and active fields are
3152| counted.
3153|
3154| Return Values : Pointer to the next field.
3155+--------------------------------------------------------------------------*/
3156NCURSES_INLINE static FIELD *
3157Next_Field_On_Page(FIELD *field)
3158{
3159 FORM *form = field->form;
3160 FIELD **field_on_page = &form->field[field->index];
3161 FIELD **first_on_page = &form->field[form->page[form->curpage].pmin];
3162 FIELD **last_on_page = &form->field[form->page[form->curpage].pmax];
3163
3164 do
3165 {
3166 field_on_page =
3167 (field_on_page == last_on_page) ? first_on_page : field_on_page + 1;
3168 if (Field_Is_Selectable(*field_on_page))
3169 break;
3170 }
3171 while (field != (*field_on_page));
3172 return (*field_on_page);
3173}
3174
3175/*---------------------------------------------------------------------------
3176| Facility : libnform
3177| Function : FIELD* _nc_First_Active_Field(FORM * form)
3178|
3179| Description : Get the first active field on the current page,
3180| if there are such. If there are none, get the first
3181| visible field on the page. If there are also none,
3182| we return the first field on page and hope the best.
3183|
3184| Return Values : Pointer to calculated field.
3185+--------------------------------------------------------------------------*/
3186NCURSES_EXPORT(FIELD *)
3187_nc_First_Active_Field(FORM *form)
3188{
3189 FIELD **last_on_page = &form->field[form->page[form->curpage].pmax];
3190 FIELD *proposed = Next_Field_On_Page(*last_on_page);
3191
3192 if (proposed == *last_on_page)
3193 {
3194 /* there might be the special situation, where there is no
3195 active and visible field on the current page. We then select
3196 the first visible field on this readonly page
3197 */
3198 if (Field_Is_Not_Selectable(proposed))
3199 {
3200 FIELD **field = &form->field[proposed->index];
3201 FIELD **first = &form->field[form->page[form->curpage].pmin];
3202
3203 do
3204 {
3205 field = (field == last_on_page) ? first : field + 1;
3206 if (((*field)->opts & O_VISIBLE))
3207 break;
3208 }
3209 while (proposed != (*field));
3210
3211 proposed = *field;
3212
3213 if ((proposed == *last_on_page) && !(proposed->opts & O_VISIBLE))
3214 {
3215 /* This means, there is also no visible field on the page.
3216 So we propose the first one and hope the very best...
3217 Some very clever user has designed a readonly and invisible
3218 page on this form.
3219 */
3220 proposed = *first;
3221 }
3222 }
3223 }
3224 return (proposed);
3225}
3226
3227/*---------------------------------------------------------------------------
3228| Facility : libnform
3229| Function : static FIELD *Previous_Field_On_Page(FIELD * field)
3230|
3231| Description : Get the previous field before the given field on the
3232| current page. The order of fields is the one defined by
3233| the fields array. Only visible and active fields are
3234| counted.
3235|
3236| Return Values : Pointer to the previous field.
3237+--------------------------------------------------------------------------*/
3238NCURSES_INLINE static FIELD *
3239Previous_Field_On_Page(FIELD *field)
3240{
3241 FORM *form = field->form;
3242 FIELD **field_on_page = &form->field[field->index];
3243 FIELD **first_on_page = &form->field[form->page[form->curpage].pmin];
3244 FIELD **last_on_page = &form->field[form->page[form->curpage].pmax];
3245
3246 do
3247 {
3248 field_on_page =
3249 (field_on_page == first_on_page) ? last_on_page : field_on_page - 1;
3250 if (Field_Is_Selectable(*field_on_page))
3251 break;
3252 }
3253 while (field != (*field_on_page));
3254
3255 return (*field_on_page);
3256}
3257
3258/*---------------------------------------------------------------------------
3259| Facility : libnform
3260| Function : static FIELD *Sorted_Next_Field(FIELD * field)
3261|
3262| Description : Get the next field after the given field on the current
3263| page. The order of fields is the one defined by the
3264| (row,column) geometry, rows are major.
3265|
3266| Return Values : Pointer to the next field.
3267+--------------------------------------------------------------------------*/
3268NCURSES_INLINE static FIELD *
3269Sorted_Next_Field(FIELD *field)
3270{
3271 FIELD *field_on_page = field;
3272
3273 do
3274 {
3275 field_on_page = field_on_page->snext;
3276 if (Field_Is_Selectable(field_on_page))
3277 break;
3278 }
3279 while (field_on_page != field);
3280
3281 return (field_on_page);
3282}
3283
3284/*---------------------------------------------------------------------------
3285| Facility : libnform
3286| Function : static FIELD *Sorted_Previous_Field(FIELD * field)
3287|
3288| Description : Get the previous field before the given field on the
3289| current page. The order of fields is the one defined
3290| by the (row,column) geometry, rows are major.
3291|
3292| Return Values : Pointer to the previous field.
3293+--------------------------------------------------------------------------*/
3294NCURSES_INLINE static FIELD *
3295Sorted_Previous_Field(FIELD *field)
3296{
3297 FIELD *field_on_page = field;
3298
3299 do
3300 {
3301 field_on_page = field_on_page->sprev;
3302 if (Field_Is_Selectable(field_on_page))
3303 break;
3304 }
3305 while (field_on_page != field);
3306
3307 return (field_on_page);
3308}
3309
3310/*---------------------------------------------------------------------------
3311| Facility : libnform
3312| Function : static FIELD *Left_Neighbor_Field(FIELD * field)
3313|
3314| Description : Get the left neighbor of the field on the same line
3315| and the same page. Cycles through the line.
3316|
3317| Return Values : Pointer to left neighbor field.
3318+--------------------------------------------------------------------------*/
3319NCURSES_INLINE static FIELD *
3320Left_Neighbor_Field(FIELD *field)
3321{
3322 FIELD *field_on_page = field;
3323
3324 /* For a field that has really a left neighbor, the while clause
3325 immediately fails and the loop is left, positioned at the right
3326 neighbor. Otherwise we cycle backwards through the sorted field list
3327 until we enter the same line (from the right end).
3328 */
3329 do
3330 {
3331 field_on_page = Sorted_Previous_Field(field_on_page);
3332 }
3333 while (field_on_page->frow != field->frow);
3334
3335 return (field_on_page);
3336}
3337
3338/*---------------------------------------------------------------------------
3339| Facility : libnform
3340| Function : static FIELD *Right_Neighbor_Field(FIELD * field)
3341|
3342| Description : Get the right neighbor of the field on the same line
3343| and the same page.
3344|
3345| Return Values : Pointer to right neighbor field.
3346+--------------------------------------------------------------------------*/
3347NCURSES_INLINE static FIELD *
3348Right_Neighbor_Field(FIELD *field)
3349{
3350 FIELD *field_on_page = field;
3351
3352 /* See the comments on Left_Neighbor_Field to understand how it works */
3353 do
3354 {
3355 field_on_page = Sorted_Next_Field(field_on_page);
3356 }
3357 while (field_on_page->frow != field->frow);
3358
3359 return (field_on_page);
3360}
3361
3362/*---------------------------------------------------------------------------
3363| Facility : libnform
3364| Function : static FIELD *Upper_Neighbor_Field(FIELD * field)
3365|
3366| Description : Because of the row-major nature of sorting the fields,
3367| it is more difficult to define whats the upper neighbor
3368| field really means. We define that it must be on a
3369| 'previous' line (cyclic order!) and is the rightmost
3370| field laying on the left side of the given field. If
3371| this set is empty, we take the first field on the line.
3372|
3373| Return Values : Pointer to the upper neighbor field.
3374+--------------------------------------------------------------------------*/
3375static FIELD *
3376Upper_Neighbor_Field(FIELD *field)
3377{
3378 FIELD *field_on_page = field;
3379 int frow = field->frow;
3380 int fcol = field->fcol;
3381
3382 /* Walk back to the 'previous' line. The second term in the while clause
3383 just guarantees that we stop if we cycled through the line because
3384 there might be no 'previous' line if the page has just one line.
3385 */
3386 do
3387 {
3388 field_on_page = Sorted_Previous_Field(field_on_page);
3389 }
3390 while (field_on_page->frow == frow && field_on_page->fcol != fcol);
3391
3392 if (field_on_page->frow != frow)
3393 {
3394 /* We really found a 'previous' line. We are positioned at the
3395 rightmost field on this line */
3396 frow = field_on_page->frow;
3397
3398 /* We walk to the left as long as we are really right of the
3399 field. */
3400 while (field_on_page->frow == frow && field_on_page->fcol > fcol)
3401 field_on_page = Sorted_Previous_Field(field_on_page);
3402
3403 /* If we wrapped, just go to the right which is the first field on
3404 the row */
3405 if (field_on_page->frow != frow)
3406 field_on_page = Sorted_Next_Field(field_on_page);
3407 }
3408
3409 return (field_on_page);
3410}
3411
3412/*---------------------------------------------------------------------------
3413| Facility : libnform
3414| Function : static FIELD *Down_Neighbor_Field(FIELD * field)
3415|
3416| Description : Because of the row-major nature of sorting the fields,
3417| its more difficult to define whats the down neighbor
3418| field really means. We define that it must be on a
3419| 'next' line (cyclic order!) and is the leftmost
3420| field laying on the right side of the given field. If
3421| this set is empty, we take the last field on the line.
3422|
3423| Return Values : Pointer to the upper neighbor field.
3424+--------------------------------------------------------------------------*/
3425static FIELD *
3426Down_Neighbor_Field(FIELD *field)
3427{
3428 FIELD *field_on_page = field;
3429 int frow = field->frow;
3430 int fcol = field->fcol;
3431
3432 /* Walk forward to the 'next' line. The second term in the while clause
3433 just guarantees that we stop if we cycled through the line because
3434 there might be no 'next' line if the page has just one line.
3435 */
3436 do
3437 {
3438 field_on_page = Sorted_Next_Field(field_on_page);
3439 }
3440 while (field_on_page->frow == frow && field_on_page->fcol != fcol);
3441
3442 if (field_on_page->frow != frow)
3443 {
3444 /* We really found a 'next' line. We are positioned at the rightmost
3445 field on this line */
3446 frow = field_on_page->frow;
3447
3448 /* We walk to the right as long as we are really left of the
3449 field. */
3450 while (field_on_page->frow == frow && field_on_page->fcol < fcol)
3451 field_on_page = Sorted_Next_Field(field_on_page);
3452
3453 /* If we wrapped, just go to the left which is the last field on
3454 the row */
3455 if (field_on_page->frow != frow)
3456 field_on_page = Sorted_Previous_Field(field_on_page);
3457 }
3458
3459 return (field_on_page);
3460}
3461
3462/*----------------------------------------------------------------------------
3463 Inter-Field Navigation routines
3464 --------------------------------------------------------------------------*/
3465
3466/*---------------------------------------------------------------------------
3467| Facility : libnform
3468| Function : static int Inter_Field_Navigation(
3469| int (* const fct) (FORM *),
3470| FORM * form)
3471|
3472| Description : Generic behavior for changing the current field, the
3473| field is left and a new field is entered. So the field
3474| must be validated and the field init/term hooks must
3475| be called.
3476|
3477| Return Values : E_OK - success
3478| E_INVALID_FIELD - field is invalid
3479| some other - error from subordinate call
3480+--------------------------------------------------------------------------*/
3481static int
3482Inter_Field_Navigation(int (*const fct) (FORM *), FORM *form)
3483{
3484 int res;
3485
3486 if (!_nc_Internal_Validation(form))
3487 res = E_INVALID_FIELD;
3488 else
3489 {
3490 Call_Hook(form, fieldterm);
3491 res = fct(form);
3492 Call_Hook(form, fieldinit);
3493 }
3494 return res;
3495}
3496
3497/*---------------------------------------------------------------------------
3498| Facility : libnform
3499| Function : static int FN_Next_Field(FORM * form)
3500|
3501| Description : Move to the next field on the current page of the form
3502|
3503| Return Values : E_OK - success
3504| != E_OK - error from subordinate call
3505+--------------------------------------------------------------------------*/
3506static int
3507FN_Next_Field(FORM *form)
3508{
3509 T((T_CALLED("FN_Next_Field(%p)"), form));
3510 returnCode(_nc_Set_Current_Field(form,
3511 Next_Field_On_Page(form->current)));
3512}
3513
3514/*---------------------------------------------------------------------------
3515| Facility : libnform
3516| Function : static int FN_Previous_Field(FORM * form)
3517|
3518| Description : Move to the previous field on the current page of the
3519| form
3520|
3521| Return Values : E_OK - success
3522| != E_OK - error from subordinate call
3523+--------------------------------------------------------------------------*/
3524static int
3525FN_Previous_Field(FORM *form)
3526{
3527 T((T_CALLED("FN_Previous_Field(%p)"), form));
3528 returnCode(_nc_Set_Current_Field(form,
3529 Previous_Field_On_Page(form->current)));
3530}
3531
3532/*---------------------------------------------------------------------------
3533| Facility : libnform
3534| Function : static int FN_First_Field(FORM * form)
3535|
3536| Description : Move to the first field on the current page of the form
3537|
3538| Return Values : E_OK - success
3539| != E_OK - error from subordinate call
3540+--------------------------------------------------------------------------*/
3541static int
3542FN_First_Field(FORM *form)
3543{
3544 T((T_CALLED("FN_First_Field(%p)"), form));
3545 returnCode(_nc_Set_Current_Field(form,
3546 Next_Field_On_Page(form->field[form->page[form->curpage].pmax])));
3547}
3548
3549/*---------------------------------------------------------------------------
3550| Facility : libnform
3551| Function : static int FN_Last_Field(FORM * form)
3552|
3553| Description : Move to the last field on the current page of the form
3554|
3555| Return Values : E_OK - success
3556| != E_OK - error from subordinate call
3557+--------------------------------------------------------------------------*/
3558static int
3559FN_Last_Field(FORM *form)
3560{
3561 T((T_CALLED("FN_Last_Field(%p)"), form));
3562 returnCode(
3563 _nc_Set_Current_Field(form,
3564 Previous_Field_On_Page(form->field[form->page[form->curpage].pmin])));
3565}
3566
3567/*---------------------------------------------------------------------------
3568| Facility : libnform
3569| Function : static int FN_Sorted_Next_Field(FORM * form)
3570|
3571| Description : Move to the sorted next field on the current page
3572| of the form.
3573|
3574| Return Values : E_OK - success
3575| != E_OK - error from subordinate call
3576+--------------------------------------------------------------------------*/
3577static int
3578FN_Sorted_Next_Field(FORM *form)
3579{
3580 T((T_CALLED("FN_Sorted_Next_Field(%p)"), form));
3581 returnCode(_nc_Set_Current_Field(form,
3582 Sorted_Next_Field(form->current)));
3583}
3584
3585/*---------------------------------------------------------------------------
3586| Facility : libnform
3587| Function : static int FN_Sorted_Previous_Field(FORM * form)
3588|
3589| Description : Move to the sorted previous field on the current page
3590| of the form.
3591|
3592| Return Values : E_OK - success
3593| != E_OK - error from subordinate call
3594+--------------------------------------------------------------------------*/
3595static int
3596FN_Sorted_Previous_Field(FORM *form)
3597{
3598 T((T_CALLED("FN_Sorted_Previous_Field(%p)"), form));
3599 returnCode(_nc_Set_Current_Field(form,
3600 Sorted_Previous_Field(form->current)));
3601}
3602
3603/*---------------------------------------------------------------------------
3604| Facility : libnform
3605| Function : static int FN_Sorted_First_Field(FORM * form)
3606|
3607| Description : Move to the sorted first field on the current page
3608| of the form.
3609|
3610| Return Values : E_OK - success
3611| != E_OK - error from subordinate call
3612+--------------------------------------------------------------------------*/
3613static int
3614FN_Sorted_First_Field(FORM *form)
3615{
3616 T((T_CALLED("FN_Sorted_First_Field(%p)"), form));
3617 returnCode(_nc_Set_Current_Field(form,
3618 Sorted_Next_Field(form->field[form->page[form->curpage].smax])));
3619}
3620
3621/*---------------------------------------------------------------------------
3622| Facility : libnform
3623| Function : static int FN_Sorted_Last_Field(FORM * form)
3624|
3625| Description : Move to the sorted last field on the current page
3626| of the form.
3627|
3628| Return Values : E_OK - success
3629| != E_OK - error from subordinate call
3630+--------------------------------------------------------------------------*/
3631static int
3632FN_Sorted_Last_Field(FORM *form)
3633{
3634 T((T_CALLED("FN_Sorted_Last_Field(%p)"), form));
3635 returnCode(_nc_Set_Current_Field(form,
3636 Sorted_Previous_Field(form->field[form->page[form->curpage].smin])));
3637}
3638
3639/*---------------------------------------------------------------------------
3640| Facility : libnform
3641| Function : static int FN_Left_Field(FORM * form)
3642|
3643| Description : Get the field on the left of the current field on the
3644| same line and the same page. Cycles through the line.
3645|
3646| Return Values : E_OK - success
3647| != E_OK - error from subordinate call
3648+--------------------------------------------------------------------------*/
3649static int
3650FN_Left_Field(FORM *form)
3651{
3652 T((T_CALLED("FN_Left_Field(%p)"), form));
3653 returnCode(_nc_Set_Current_Field(form,
3654 Left_Neighbor_Field(form->current)));
3655}
3656
3657/*---------------------------------------------------------------------------
3658| Facility : libnform
3659| Function : static int FN_Right_Field(FORM * form)
3660|
3661| Description : Get the field on the right of the current field on the
3662| same line and the same page. Cycles through the line.
3663|
3664| Return Values : E_OK - success
3665| != E_OK - error from subordinate call
3666+--------------------------------------------------------------------------*/
3667static int
3668FN_Right_Field(FORM *form)
3669{
3670 T((T_CALLED("FN_Right_Field(%p)"), form));
3671 returnCode(_nc_Set_Current_Field(form,
3672 Right_Neighbor_Field(form->current)));
3673}
3674
3675/*---------------------------------------------------------------------------
3676| Facility : libnform
3677| Function : static int FN_Up_Field(FORM * form)
3678|
3679| Description : Get the upper neighbor of the current field. This
3680| cycles through the page. See the comments of the
3681| Upper_Neighbor_Field function to understand how
3682| 'upper' is defined.
3683|
3684| Return Values : E_OK - success
3685| != E_OK - error from subordinate call
3686+--------------------------------------------------------------------------*/
3687static int
3688FN_Up_Field(FORM *form)
3689{
3690 T((T_CALLED("FN_Up_Field(%p)"), form));
3691 returnCode(_nc_Set_Current_Field(form,
3692 Upper_Neighbor_Field(form->current)));
3693}
3694
3695/*---------------------------------------------------------------------------
3696| Facility : libnform
3697| Function : static int FN_Down_Field(FORM * form)
3698|
3699| Description : Get the down neighbor of the current field. This
3700| cycles through the page. See the comments of the
3701| Down_Neighbor_Field function to understand how
3702| 'down' is defined.
3703|
3704| Return Values : E_OK - success
3705| != E_OK - error from subordinate call
3706+--------------------------------------------------------------------------*/
3707static int
3708FN_Down_Field(FORM *form)
3709{
3710 T((T_CALLED("FN_Down_Field(%p)"), form));
3711 returnCode(_nc_Set_Current_Field(form,
3712 Down_Neighbor_Field(form->current)));
3713}
3714/*----------------------------------------------------------------------------
3715 END of Field Navigation routines
3716 --------------------------------------------------------------------------*/
3717
3718/*----------------------------------------------------------------------------
3719 Helper routines for Page Navigation
3720 --------------------------------------------------------------------------*/
3721
3722/*---------------------------------------------------------------------------
3723| Facility : libnform
3724| Function : int _nc_Set_Form_Page(FORM * form,
3725| int page,
3726| FIELD * field)
3727|
3728| Description : Make the given page number the current page and make
3729| the given field the current field on the page. If
3730| for the field NULL is given, make the first field on
3731| the page the current field. The routine acts only
3732| if the requested page is not the current page.
3733|
3734| Return Values : E_OK - success
3735| != E_OK - error from subordinate call
3736| E_BAD_ARGUMENT - invalid field pointer
3737| E_SYSTEM_ERROR - some severe basic error
3738+--------------------------------------------------------------------------*/
3739NCURSES_EXPORT(int)
3740_nc_Set_Form_Page(FORM *form, int page, FIELD *field)
3741{
3742 int res = E_OK;
3743
3744 if ((form->curpage != page))
3745 {
3746 FIELD *last_field, *field_on_page;
3747
3748 werase(Get_Form_Window(form));
3749 form->curpage = page;
3750 last_field = field_on_page = form->field[form->page[page].smin];
3751 do
3752 {
3753 if (field_on_page->opts & O_VISIBLE)
3754 if ((res = Display_Field(field_on_page)) != E_OK)
3755 return (res);
3756 field_on_page = field_on_page->snext;
3757 }
3758 while (field_on_page != last_field);
3759
3760 if (field)
3761 res = _nc_Set_Current_Field(form, field);
3762 else
3763 /* N.B.: we don't encapsulate this by Inter_Field_Navigation(),
3764 because this is already executed in a page navigation
3765 context that contains field navigation
3766 */
3767 res = FN_First_Field(form);
3768 }
3769 return (res);
3770}
3771
3772/*---------------------------------------------------------------------------
3773| Facility : libnform
3774| Function : static int Next_Page_Number(const FORM * form)
3775|
3776| Description : Calculate the page number following the current page
3777| number. This cycles if the highest page number is
3778| reached.
3779|
3780| Return Values : The next page number
3781+--------------------------------------------------------------------------*/
3782NCURSES_INLINE static int
3783Next_Page_Number(const FORM *form)
3784{
3785 return (form->curpage + 1) % form->maxpage;
3786}
3787
3788/*---------------------------------------------------------------------------
3789| Facility : libnform
3790| Function : static int Previous_Page_Number(const FORM * form)
3791|
3792| Description : Calculate the page number before the current page
3793| number. This cycles if the first page number is
3794| reached.
3795|
3796| Return Values : The previous page number
3797+--------------------------------------------------------------------------*/
3798NCURSES_INLINE static int
3799Previous_Page_Number(const FORM *form)
3800{
3801 return (form->curpage != 0 ? form->curpage - 1 : form->maxpage - 1);
3802}
3803
3804/*----------------------------------------------------------------------------
3805 Page Navigation routines
3806 --------------------------------------------------------------------------*/
3807
3808/*---------------------------------------------------------------------------
3809| Facility : libnform
3810| Function : static int Page_Navigation(
3811| int (* const fct) (FORM *),
3812| FORM * form)
3813|
3814| Description : Generic behavior for changing a page. This means
3815| that the field is left and a new field is entered.
3816| So the field must be validated and the field init/term
3817| hooks must be called. Because also the page is changed,
3818| the forms init/term hooks must be called also.
3819|
3820| Return Values : E_OK - success
3821| E_INVALID_FIELD - field is invalid
3822| some other - error from subordinate call
3823+--------------------------------------------------------------------------*/
3824static int
3825Page_Navigation(int (*const fct) (FORM *), FORM *form)
3826{
3827 int res;
3828
3829 if (!_nc_Internal_Validation(form))
3830 res = E_INVALID_FIELD;
3831 else
3832 {
3833 Call_Hook(form, fieldterm);
3834 Call_Hook(form, formterm);
3835 res = fct(form);
3836 Call_Hook(form, forminit);
3837 Call_Hook(form, fieldinit);
3838 }
3839 return res;
3840}
3841
3842/*---------------------------------------------------------------------------
3843| Facility : libnform
3844| Function : static int PN_Next_Page(FORM * form)
3845|
3846| Description : Move to the next page of the form
3847|
3848| Return Values : E_OK - success
3849| != E_OK - error from subordinate call
3850+--------------------------------------------------------------------------*/
3851static int
3852PN_Next_Page(FORM *form)
3853{
3854 T((T_CALLED("PN_Next_Page(%p)"), form));
3855 returnCode(_nc_Set_Form_Page(form, Next_Page_Number(form), (FIELD *)0));
3856}
3857
3858/*---------------------------------------------------------------------------
3859| Facility : libnform
3860| Function : static int PN_Previous_Page(FORM * form)
3861|
3862| Description : Move to the previous page of the form
3863|
3864| Return Values : E_OK - success
3865| != E_OK - error from subordinate call
3866+--------------------------------------------------------------------------*/
3867static int
3868PN_Previous_Page(FORM *form)
3869{
3870 T((T_CALLED("PN_Previous_Page(%p)"), form));
3871 returnCode(_nc_Set_Form_Page(form, Previous_Page_Number(form), (FIELD *)0));
3872}
3873
3874/*---------------------------------------------------------------------------
3875| Facility : libnform
3876| Function : static int PN_First_Page(FORM * form)
3877|
3878| Description : Move to the first page of the form
3879|
3880| Return Values : E_OK - success
3881| != E_OK - error from subordinate call
3882+--------------------------------------------------------------------------*/
3883static int
3884PN_First_Page(FORM *form)
3885{
3886 T((T_CALLED("PN_First_Page(%p)"), form));
3887 returnCode(_nc_Set_Form_Page(form, 0, (FIELD *)0));
3888}
3889
3890/*---------------------------------------------------------------------------
3891| Facility : libnform
3892| Function : static int PN_Last_Page(FORM * form)
3893|
3894| Description : Move to the last page of the form
3895|
3896| Return Values : E_OK - success
3897| != E_OK - error from subordinate call
3898+--------------------------------------------------------------------------*/
3899static int
3900PN_Last_Page(FORM *form)
3901{
3902 T((T_CALLED("PN_Last_Page(%p)"), form));
3903 returnCode(_nc_Set_Form_Page(form, form->maxpage - 1, (FIELD *)0));
3904}
3905
3906/*----------------------------------------------------------------------------
3907 END of Field Navigation routines
3908 --------------------------------------------------------------------------*/
3909
3910/*----------------------------------------------------------------------------
3911 Helper routines for the core form driver.
3912 --------------------------------------------------------------------------*/
3913
3914/*---------------------------------------------------------------------------
3915| Facility : libnform
3916| Function : static int Data_Entry(FORM * form,int c)
3917|
3918| Description : Enter character c into at the current position of the
3919| current field of the form.
3920|
3921| Return Values : E_OK - success
3922| E_REQUEST_DENIED - driver could not process the request
3923| E_SYSTEM_ERROR -
3924+--------------------------------------------------------------------------*/
3925static int
3926Data_Entry(FORM *form, int c)
3927{
3928 FIELD *field = form->current;
3929 int result = E_REQUEST_DENIED;
3930
3931 T((T_CALLED("Data_Entry(%p,%s)"), form, _tracechtype((chtype)c)));
3932 if ((field->opts & O_EDIT)
3933#if FIX_FORM_INACTIVE_BUG
3934 && (field->opts & O_ACTIVE)
3935#endif
3936 )
3937 {
3938 if ((field->opts & O_BLANK) &&
3939 First_Position_In_Current_Field(form) &&
3940 !(form->status & _FCHECK_REQUIRED) &&
3941 !(form->status & _WINDOW_MODIFIED))
3942 werase(form->w);
3943
3944 if (form->status & _OVLMODE)
3945 {
3946 waddch(form->w, (chtype)c);
3947 }
3948 else
3949 /* no _OVLMODE */
3950 {
3951 bool There_Is_Room = Is_There_Room_For_A_Char_In_Line(form);
3952
3953 if (!(There_Is_Room ||
3954 ((Single_Line_Field(field) && Growable(field)))))
3955 RETURN(E_REQUEST_DENIED);
3956
3957 if (!There_Is_Room && !Field_Grown(field, 1))
3958 RETURN(E_SYSTEM_ERROR);
3959
3960 winsch(form->w, (chtype)c);
3961 }
3962
3963 if ((result = Wrapping_Not_Necessary_Or_Wrapping_Ok(form)) == E_OK)
3964 {
3965 bool End_Of_Field = (((field->drows - 1) == form->currow) &&
3966 ((field->dcols - 1) == form->curcol));
3967
3968 form->status |= _WINDOW_MODIFIED;
3969 if (End_Of_Field && !Growable(field) && (field->opts & O_AUTOSKIP))
3970 result = Inter_Field_Navigation(FN_Next_Field, form);
3971 else
3972 {
3973 if (End_Of_Field && Growable(field) && !Field_Grown(field, 1))
3974 result = E_SYSTEM_ERROR;
3975 else
3976 {
3977#if USE_WIDEC_SUPPORT
3978 /*
3979 * We have just added a byte to the form field. It may have
3980 * been part of a multibyte character. If it was, the
3981 * addch_used field is nonzero and we should not try to move
3982 * to a new column.
3983 */
3984 if (WINDOW_EXT(form->w, addch_used) == 0)
3985 IFN_Next_Character(form);
3986#else
3987 IFN_Next_Character(form);
3988#endif
3989 result = E_OK;
3990 }
3991 }
3992 }
3993 }
3994 RETURN(result);
3995}
3996
3997/* Structure to describe the binding of a request code to a function.
3998 The member keycode codes the request value as well as the generic
3999 routine to use for the request. The code for the generic routine
4000 is coded in the upper 16 Bits while the request code is coded in
4001 the lower 16 bits.
4002
4003 In terms of C++ you might think of a request as a class with a
4004 virtual method "perform". The different types of request are
4005 derived from this base class and overload (or not) the base class
4006 implementation of perform.
4007*/
4008typedef struct
4009{
4010 int keycode; /* must be at least 32 bit: hi:mode, lo: key */
4011 int (*cmd) (FORM *); /* low level driver routine for this key */
4012}
4013Binding_Info;
4014
4015/* You may see this is the class-id of the request type class */
4016#define ID_PN (0x00000000) /* Page navigation */
4017#define ID_FN (0x00010000) /* Inter-Field navigation */
4018#define ID_IFN (0x00020000) /* Intra-Field navigation */
4019#define ID_VSC (0x00030000) /* Vertical Scrolling */
4020#define ID_HSC (0x00040000) /* Horizontal Scrolling */
4021#define ID_FE (0x00050000) /* Field Editing */
4022#define ID_EM (0x00060000) /* Edit Mode */
4023#define ID_FV (0x00070000) /* Field Validation */
4024#define ID_CH (0x00080000) /* Choice */
4025#define ID_Mask (0xffff0000)
4026#define Key_Mask (0x0000ffff)
4027#define ID_Shft (16)
4028
4029/* This array holds all the Binding Infos */
4030/* *INDENT-OFF* */
4031static const Binding_Info bindings[MAX_FORM_COMMAND - MIN_FORM_COMMAND + 1] =
4032{
4033 { REQ_NEXT_PAGE |ID_PN ,PN_Next_Page},
4034 { REQ_PREV_PAGE |ID_PN ,PN_Previous_Page},
4035 { REQ_FIRST_PAGE |ID_PN ,PN_First_Page},
4036 { REQ_LAST_PAGE |ID_PN ,PN_Last_Page},
4037
4038 { REQ_NEXT_FIELD |ID_FN ,FN_Next_Field},
4039 { REQ_PREV_FIELD |ID_FN ,FN_Previous_Field},
4040 { REQ_FIRST_FIELD |ID_FN ,FN_First_Field},
4041 { REQ_LAST_FIELD |ID_FN ,FN_Last_Field},
4042 { REQ_SNEXT_FIELD |ID_FN ,FN_Sorted_Next_Field},
4043 { REQ_SPREV_FIELD |ID_FN ,FN_Sorted_Previous_Field},
4044 { REQ_SFIRST_FIELD |ID_FN ,FN_Sorted_First_Field},
4045 { REQ_SLAST_FIELD |ID_FN ,FN_Sorted_Last_Field},
4046 { REQ_LEFT_FIELD |ID_FN ,FN_Left_Field},
4047 { REQ_RIGHT_FIELD |ID_FN ,FN_Right_Field},
4048 { REQ_UP_FIELD |ID_FN ,FN_Up_Field},
4049 { REQ_DOWN_FIELD |ID_FN ,FN_Down_Field},
4050
4051 { REQ_NEXT_CHAR |ID_IFN ,IFN_Next_Character},
4052 { REQ_PREV_CHAR |ID_IFN ,IFN_Previous_Character},
4053 { REQ_NEXT_LINE |ID_IFN ,IFN_Next_Line},
4054 { REQ_PREV_LINE |ID_IFN ,IFN_Previous_Line},
4055 { REQ_NEXT_WORD |ID_IFN ,IFN_Next_Word},
4056 { REQ_PREV_WORD |ID_IFN ,IFN_Previous_Word},
4057 { REQ_BEG_FIELD |ID_IFN ,IFN_Beginning_Of_Field},
4058 { REQ_END_FIELD |ID_IFN ,IFN_End_Of_Field},
4059 { REQ_BEG_LINE |ID_IFN ,IFN_Beginning_Of_Line},
4060 { REQ_END_LINE |ID_IFN ,IFN_End_Of_Line},
4061 { REQ_LEFT_CHAR |ID_IFN ,IFN_Left_Character},
4062 { REQ_RIGHT_CHAR |ID_IFN ,IFN_Right_Character},
4063 { REQ_UP_CHAR |ID_IFN ,IFN_Up_Character},
4064 { REQ_DOWN_CHAR |ID_IFN ,IFN_Down_Character},
4065
4066 { REQ_NEW_LINE |ID_FE ,FE_New_Line},
4067 { REQ_INS_CHAR |ID_FE ,FE_Insert_Character},
4068 { REQ_INS_LINE |ID_FE ,FE_Insert_Line},
4069 { REQ_DEL_CHAR |ID_FE ,FE_Delete_Character},
4070 { REQ_DEL_PREV |ID_FE ,FE_Delete_Previous},
4071 { REQ_DEL_LINE |ID_FE ,FE_Delete_Line},
4072 { REQ_DEL_WORD |ID_FE ,FE_Delete_Word},
4073 { REQ_CLR_EOL |ID_FE ,FE_Clear_To_End_Of_Line},
4074 { REQ_CLR_EOF |ID_FE ,FE_Clear_To_End_Of_Field},
4075 { REQ_CLR_FIELD |ID_FE ,FE_Clear_Field},
4076
4077 { REQ_OVL_MODE |ID_EM ,EM_Overlay_Mode},
4078 { REQ_INS_MODE |ID_EM ,EM_Insert_Mode},
4079
4080 { REQ_SCR_FLINE |ID_VSC ,VSC_Scroll_Line_Forward},
4081 { REQ_SCR_BLINE |ID_VSC ,VSC_Scroll_Line_Backward},
4082 { REQ_SCR_FPAGE |ID_VSC ,VSC_Scroll_Page_Forward},
4083 { REQ_SCR_BPAGE |ID_VSC ,VSC_Scroll_Page_Backward},
4084 { REQ_SCR_FHPAGE |ID_VSC ,VSC_Scroll_Half_Page_Forward},
4085 { REQ_SCR_BHPAGE |ID_VSC ,VSC_Scroll_Half_Page_Backward},
4086
4087 { REQ_SCR_FCHAR |ID_HSC ,HSC_Scroll_Char_Forward},
4088 { REQ_SCR_BCHAR |ID_HSC ,HSC_Scroll_Char_Backward},
4089 { REQ_SCR_HFLINE |ID_HSC ,HSC_Horizontal_Line_Forward},
4090 { REQ_SCR_HBLINE |ID_HSC ,HSC_Horizontal_Line_Backward},
4091 { REQ_SCR_HFHALF |ID_HSC ,HSC_Horizontal_Half_Line_Forward},
4092 { REQ_SCR_HBHALF |ID_HSC ,HSC_Horizontal_Half_Line_Backward},
4093
4094 { REQ_VALIDATION |ID_FV ,FV_Validation},
4095
4096 { REQ_NEXT_CHOICE |ID_CH ,CR_Next_Choice},
4097 { REQ_PREV_CHOICE |ID_CH ,CR_Previous_Choice}
4098};
4099/* *INDENT-ON* */
4100
4101/*---------------------------------------------------------------------------
4102| Facility : libnform
4103| Function : int form_driver(FORM * form,int c)
4104|
4105| Description : This is the workhorse of the forms system. It checks
4106| to determine whether the character c is a request or
4107| data. If it is a request, the form driver executes
4108| the request and returns the result. If it is data
4109| (printable character), it enters the data into the
4110| current position in the current field. If it is not
4111| recognized, the form driver assumes it is an application
4112| defined command and returns E_UNKNOWN_COMMAND.
4113| Application defined command should be defined relative
4114| to MAX_FORM_COMMAND, the maximum value of a request.
4115|
4116| Return Values : E_OK - success
4117| E_SYSTEM_ERROR - system error
4118| E_BAD_ARGUMENT - an argument is incorrect
4119| E_NOT_POSTED - form is not posted
4120| E_INVALID_FIELD - field contents are invalid
4121| E_BAD_STATE - called from inside a hook routine
4122| E_REQUEST_DENIED - request failed
4123| E_NOT_CONNECTED - no fields are connected to the form
4124| E_UNKNOWN_COMMAND - command not known
4125+--------------------------------------------------------------------------*/
4126NCURSES_EXPORT(int)
4127form_driver(FORM *form, int c)
4128{
4129 const Binding_Info *BI = (Binding_Info *) 0;
4130 int res = E_UNKNOWN_COMMAND;
4131
4132 T((T_CALLED("form_driver(%p,%d)"), form, c));
4133
4134 if (!form)
4135 RETURN(E_BAD_ARGUMENT);
4136
4137 if (!(form->field))
4138 RETURN(E_NOT_CONNECTED);
4139
4140 assert(form->page);
4141
4142 if (c == FIRST_ACTIVE_MAGIC)
4143 {
4144 form->current = _nc_First_Active_Field(form);
4145 RETURN(E_OK);
4146 }
4147
4148 assert(form->current &&
4149 form->current->buf &&
4150 (form->current->form == form)
4151 );
4152
4153 if (form->status & _IN_DRIVER)
4154 RETURN(E_BAD_STATE);
4155
4156 if (!(form->status & _POSTED))
4157 RETURN(E_NOT_POSTED);
4158
4159 if ((c >= MIN_FORM_COMMAND && c <= MAX_FORM_COMMAND) &&
4160 ((bindings[c - MIN_FORM_COMMAND].keycode & Key_Mask) == c))
4161 BI = &(bindings[c - MIN_FORM_COMMAND]);
4162
4163 if (BI)
4164 {
4165 typedef int (*Generic_Method) (int (*const) (FORM *), FORM *);
4166 static const Generic_Method Generic_Methods[] =
4167 {
4168 Page_Navigation, /* overloaded to call field&form hooks */
4169 Inter_Field_Navigation, /* overloaded to call field hooks */
4170 NULL, /* Intra-Field is generic */
4171 Vertical_Scrolling, /* Overloaded to check multi-line */
4172 Horizontal_Scrolling, /* Overloaded to check single-line */
4173 Field_Editing, /* Overloaded to mark modification */
4174 NULL, /* Edit Mode is generic */
4175 NULL, /* Field Validation is generic */
4176 NULL /* Choice Request is generic */
4177 };
4178 size_t nMethods = (sizeof(Generic_Methods) / sizeof(Generic_Methods[0]));
4179 size_t method = ((BI->keycode & ID_Mask) >> ID_Shft) & 0xffff;
4180
4181 if ((method >= nMethods) || !(BI->cmd))
4182 res = E_SYSTEM_ERROR;
4183 else
4184 {
4185 Generic_Method fct = Generic_Methods[method];
4186
4187 if (fct)
4188 res = fct(BI->cmd, form);
4189 else
4190 res = (BI->cmd) (form);
4191 }
4192 }
4193#ifdef NCURSES_MOUSE_VERSION
4194 else if (KEY_MOUSE == c)
4195 {
4196 MEVENT event;
4197 WINDOW *win = form->win ? form->win : stdscr;
4198 WINDOW *sub = form->sub ? form->sub : win;
4199
4200 getmouse(&event);
4201 if ((event.bstate & (BUTTON1_CLICKED |
4202 BUTTON1_DOUBLE_CLICKED |
4203 BUTTON1_TRIPLE_CLICKED))
4204 && wenclose(win, event.y, event.x))
4205 { /* we react only if the click was in the userwin, that means
4206 * inside the form display area or at the decoration window.
4207 */
4208 int ry = event.y, rx = event.x; /* screen coordinates */
4209
4210 res = E_REQUEST_DENIED;
4211 if (mouse_trafo(&ry, &rx, FALSE))
4212 { /* rx, ry are now "curses" coordinates */
4213 if (ry < sub->_begy)
4214 { /* we clicked above the display region; this is
4215 * interpreted as "scroll up" request
4216 */
4217 if (event.bstate & BUTTON1_CLICKED)
4218 res = form_driver(form, REQ_PREV_FIELD);
4219 else if (event.bstate & BUTTON1_DOUBLE_CLICKED)
4220 res = form_driver(form, REQ_PREV_PAGE);
4221 else if (event.bstate & BUTTON1_TRIPLE_CLICKED)
4222 res = form_driver(form, REQ_FIRST_FIELD);
4223 }
4224 else if (ry > sub->_begy + sub->_maxy)
4225 { /* we clicked below the display region; this is
4226 * interpreted as "scroll down" request
4227 */
4228 if (event.bstate & BUTTON1_CLICKED)
4229 res = form_driver(form, REQ_NEXT_FIELD);
4230 else if (event.bstate & BUTTON1_DOUBLE_CLICKED)
4231 res = form_driver(form, REQ_NEXT_PAGE);
4232 else if (event.bstate & BUTTON1_TRIPLE_CLICKED)
4233 res = form_driver(form, REQ_LAST_FIELD);
4234 }
4235 else if (wenclose(sub, event.y, event.x))
4236 { /* Inside the area we try to find the hit item */
4237 int i;
4238
4239 ry = event.y;
4240 rx = event.x;
4241 if (wmouse_trafo(sub, &ry, &rx, FALSE))
4242 {
4243 int min_field = form->page[form->curpage].pmin;
4244 int max_field = form->page[form->curpage].pmax;
4245
4246 for (i = min_field; i <= max_field; ++i)
4247 {
4248 FIELD *field = form->field[i];
4249
4250 if (Field_Is_Selectable(field)
4251 && Field_encloses(field, ry, rx) == E_OK)
4252 {
4253 res = _nc_Set_Current_Field(form, field);
4254 if (res == E_OK)
4255 res = _nc_Position_Form_Cursor(form);
4256 if (res == E_OK
4257 && (event.bstate & BUTTON1_DOUBLE_CLICKED))
4258 res = E_UNKNOWN_COMMAND;
4259 break;
4260 }
4261 }
4262 }
4263 }
4264 }
4265 }
4266 else
4267 res = E_REQUEST_DENIED;
4268 }
4269#endif /* NCURSES_MOUSE_VERSION */
4270 else if (!(c & (~(int)MAX_REGULAR_CHARACTER)))
4271 {
4272 /*
4273 * If we're using 8-bit characters, iscntrl+isprint cover the whole set.
4274 * But with multibyte characters, there is a third possibility, i.e.,
4275 * parts of characters that build up into printable characters which are
4276 * not considered printable.
4277 *
4278 * FIXME: the wide-character branch should also use Check_Char().
4279 */
4280#if USE_WIDEC_SUPPORT
4281 if (!iscntrl(UChar(c)))
4282#else
4283 if (isprint(UChar(c)) &&
4284 Check_Char(form->current->type, c,
4285 (TypeArgument *)(form->current->arg)))
4286#endif
4287 res = Data_Entry(form, c);
4288 }
4289 _nc_Refresh_Current_Field(form);
4290 RETURN(res);
4291}
4292
4293/*----------------------------------------------------------------------------
4294 Field-Buffer manipulation routines.
4295 The effects of setting a buffer are tightly coupled to the core of the form
4296 driver logic. This is especially true in the case of growable fields.
4297 So I don't separate this into a separate module.
4298 --------------------------------------------------------------------------*/
4299
4300/*---------------------------------------------------------------------------
4301| Facility : libnform
4302| Function : int set_field_buffer(FIELD *field,
4303| int buffer, char *value)
4304|
4305| Description : Set the given buffer of the field to the given value.
4306| Buffer 0 stores the displayed content of the field.
4307| For dynamic fields this may grow the fieldbuffers if
4308| the length of the value exceeds the current buffer
4309| length. For buffer 0 only printable values are allowed.
4310| For static fields, the value needs not to be zero ter-
4311| minated. It is copied up to the length of the buffer.
4312|
4313| Return Values : E_OK - success
4314| E_BAD_ARGUMENT - invalid argument
4315| E_SYSTEM_ERROR - system error
4316+--------------------------------------------------------------------------*/
4317NCURSES_EXPORT(int)
4318set_field_buffer(FIELD *field, int buffer, const char *value)
4319{
4320 FIELD_CELL *p;
4321 int res = E_OK;
4322 unsigned int i;
4323 unsigned int len;
4324
4325#if USE_WIDEC_SUPPORT
4326 FIELD_CELL *widevalue = 0;
4327#endif
4328
4329 T((T_CALLED("set_field_buffer(%p,%d,%s)"), field, buffer, _nc_visbuf(value)));
4330
4331 if (!field || !value || ((buffer < 0) || (buffer > field->nbuf)))
4332 RETURN(E_BAD_ARGUMENT);
4333
4334 len = Buffer_Length(field);
4335
4336 if (buffer == 0)
4337 {
4338 for (i = 0; (value[i] != '\0') && (i < len); ++i)
4339 {
4340 if (iscntrl(UChar(value[i])))
4341 RETURN(E_BAD_ARGUMENT);
4342 }
4343 }
4344
4345 if (Growable(field))
4346 {
4347 /* for a growable field we must assume zero terminated strings, because
4348 somehow we have to detect the length of what should be copied.
4349 */
4350 unsigned int vlen = strlen(value);
4351
4352 if (vlen > len)
4353 {
4354 if (!Field_Grown(field,
4355 (int)(1 + (vlen - len) / ((field->rows + field->nrow)
4356 * field->cols))))
4357 RETURN(E_SYSTEM_ERROR);
4358
4359 /* in this case we also have to check, whether or not the remaining
4360 characters in value are also printable for buffer 0. */
4361 if (buffer == 0)
4362 {
4363 for (i = len; i < vlen; i++)
4364 if (iscntrl(UChar(value[i])))
4365 RETURN(E_BAD_ARGUMENT);
4366 }
4367 len = vlen;
4368 }
4369 }
4370
4371 p = Address_Of_Nth_Buffer(field, buffer);
4372
4373#if USE_WIDEC_SUPPORT
4374 /*
4375 * Use addstr's logic for converting a string to an array of cchar_t's.
4376 * There should be a better way, but this handles nonspacing characters
4377 * and other special cases that we really do not want to handle here.
4378 */
4379 wclear(field->working);
4380 mvwaddstr(field->working, 0, 0, value);
4381
4382 if ((widevalue = typeCalloc(FIELD_CELL, len + 1)) == 0)
4383 {
4384 RETURN(E_SYSTEM_ERROR);
4385 }
4386 else
4387 {
4388 mvwin_wchnstr(field->working, 0, 0, widevalue, (int)len);
4389 for (i = 0; i < len; ++i)
4390 {
4391 if (CharEq(myZEROS, widevalue[i]))
4392 {
4393 while (i < len)
4394 p[i++] = myBLANK;
4395 break;
4396 }
4397 p[i] = widevalue[i];
4398 }
4399 free(widevalue);
4400 }
4401#else
4402 for (i = 0; i < len; ++i)
4403 {
4404 if (value[i] == '\0')
4405 {
4406 while (i < len)
4407 p[i++] = myBLANK;
4408 break;
4409 }
4410 p[i] = value[i];
4411 }
4412#endif
4413
4414 if (buffer == 0)
4415 {
4416 int syncres;
4417
4418 if (((syncres = Synchronize_Field(field)) != E_OK) &&
4419 (res == E_OK))
4420 res = syncres;
4421 if (((syncres = Synchronize_Linked_Fields(field)) != E_OK) &&
4422 (res == E_OK))
4423 res = syncres;
4424 }
4425 RETURN(res);
4426}
4427
4428/*---------------------------------------------------------------------------
4429| Facility : libnform
4430| Function : char *field_buffer(const FIELD *field,int buffer)
4431|
4432| Description : Return the address of the buffer for the field.
4433|
4434| Return Values : Pointer to buffer or NULL if arguments were invalid.
4435+--------------------------------------------------------------------------*/
4436NCURSES_EXPORT(char *)
4437field_buffer(const FIELD *field, int buffer)
4438{
4439 char *result = 0;
4440
4441 T((T_CALLED("field_buffer(%p,%d)"), field, buffer));
4442
4443 if (field && (buffer >= 0) && (buffer <= field->nbuf))
4444 {
4445#if USE_WIDEC_SUPPORT
4446 FIELD_CELL *data = Address_Of_Nth_Buffer(field, buffer);
4447 unsigned need = 0;
4448 int size = Buffer_Length(field);
4449 int n;
4450
4451 /* determine the number of bytes needed to store the expanded string */
4452 for (n = 0; n < size; ++n)
4453 {
4454 if (!isWidecExt(data[n]))
4455 {
4456 mbstate_t state;
4457 size_t next;
4458
4459 init_mb(state);
4460 next = _nc_wcrtomb(0, data[n].chars[0], &state);
4461 if (!isEILSEQ(next))
4462 need += next;
4463 }
4464 }
4465
4466 /* allocate a place to store the expanded string */
4467 if (field->expanded[buffer] != 0)
4468 free(field->expanded[buffer]);
4469 field->expanded[buffer] = typeMalloc(char, need + 1);
4470
4471 /* expand the multibyte data */
4472 if ((result = field->expanded[buffer]) != 0)
4473 {
4474 wclear(field->working);
4475 mvwadd_wchnstr(field->working, 0, 0, data, size);
4476 mvwinnstr(field->working, 0, 0, result, (int)need);
4477 }
4478#else
4479 result = Address_Of_Nth_Buffer(field, buffer);
4480#endif
4481 }
4482 returnPtr(result);
4483}
4484
4485#if USE_WIDEC_SUPPORT
4486
4487/* FIXME: see lib_get_wch.c */
4488#if HAVE_MBTOWC && HAVE_MBLEN
4489#define reset_mbytes(state) mblen(NULL, 0), mbtowc(NULL, NULL, 0)
4490#define count_mbytes(buffer,length,state) mblen(buffer,length)
4491#define trans_mbytes(wch,buffer,length,state) \
4492 (int) mbtowc(&wch, buffer, length)
4493#elif HAVE_MBRTOWC && HAVE_MBRLEN
4494#define NEED_STATE
4495#define reset_mbytes(state) init_mb(state)
4496#define count_mbytes(buffer,length,state) mbrlen(buffer,length,&state)
4497#define trans_mbytes(wch,buffer,length,state) \
4498 (int) mbrtowc(&wch, buffer, length, &state)
4499#else
4500make an error
4501#endif
4502
4503/*---------------------------------------------------------------------------
4504| Convert a multibyte string to a wide-character string. The result must be
4505| freed by the caller.
4506+--------------------------------------------------------------------------*/
4507NCURSES_EXPORT(wchar_t *)
4508_nc_Widen_String(char *source, int *lengthp)
4509{
4510 wchar_t *result = 0;
4511 wchar_t wch;
4512 size_t given = strlen(source);
4513 size_t tries;
4514 int pass;
4515 int status;
4516
4517#ifdef NEED_STATE
4518 mbstate_t state;
4519#endif
4520
4521 for (pass = 0; pass < 2; ++pass)
4522 {
4523 unsigned need = 0;
4524 size_t passed = 0;
4525
4526 while (passed < given)
4527 {
4528 bool found = FALSE;
4529
4530 for (tries = 1, status = 0; tries <= (given - passed); ++tries)
4531 {
4532 int save = source[passed + tries];
4533
4534 source[passed + tries] = 0;
4535 reset_mbytes(state);
4536 status = trans_mbytes(wch, source + passed, tries, state);
4537 source[passed + tries] = save;
4538
4539 if (status > 0)
4540 {
4541 found = TRUE;
4542 break;
4543 }
4544 }
4545 if (found)
4546 {
4547 if (pass)
4548 {
4549 result[need] = wch;
4550 }
4551 passed += status;
4552 ++need;
4553 }
4554 else
4555 {
4556 if (pass)
4557 {
4558 result[need] = source[passed];
4559 }
4560 ++need;
4561 ++passed;
4562 }
4563 }
4564
4565 if (!pass)
4566 {
4567 if (!need)
4568 break;
4569 result = typeCalloc(wchar_t, need);
4570
4571 *lengthp = need;
4572 if (result == 0)
4573 break;
4574 }
4575 }
4576
4577 return result;
4578}
4579#endif
4580
4581/* frm_driver.c ends here */
|