1 /****************************************************************************
2 * Copyright (c) 2008 Free Software Foundation, Inc. *
4 * Permission is hereby granted, free of charge, to any person obtaining a *
5 * copy of this software and associated documentation files (the *
6 * "Software"), to deal in the Software without restriction, including *
7 * without limitation the rights to use, copy, modify, merge, publish, *
8 * distribute, distribute with modifications, sublicense, and/or sell *
9 * copies of the Software, and to permit persons to whom the Software is *
10 * furnished to do so, subject to the following conditions: *
12 * The above copyright notice and this permission notice shall be included *
13 * in all copies or substantial portions of the Software. *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS *
16 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF *
17 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. *
18 * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, *
19 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR *
20 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR *
21 * THE USE OR OTHER DEALINGS IN THE SOFTWARE. *
23 * Except as contained in this notice, the name(s) of the above copyright *
24 * holders shall not be used in advertising or otherwise to promote the *
25 * sale, use or other dealings in this Software without prior written *
27 ****************************************************************************/
29 /***************************************************************************
31 * Author : Juergen Pfeifer *
33 ***************************************************************************/
35 #include "form.priv.h"
37 MODULE_ID("$Id: fty_generic.c,v 1.1 2008/11/18 08:50:04 juergen Exp $")
40 * This is not a full implementation of a field type, but adds some
41 * support for higher level languages with some restrictions to interop
42 * with C language. Especially the collection of arguments for the
43 * various fieldtypes is not based on the vararg C mechanism, but on a
44 * iterator based callback mechanism that allowes the high level language
45 * to provide the arguments as a structure. Most languages have mechanisms
46 * to layout structures so that they can be passed to C.
47 * The languages can register a new generic fieldtype dynamically and store
48 * a handle (key) to the calling object as an argument. Together with that
49 * it can register a freearg callback, so that the high level language
50 * remains in control of the memory management of the arguments they pass.
51 * The design idea is, that the high-level language - typically a OO
52 * language like C# or Java, uses it's own dispatching mechanisms
53 * (polymorphism) to call the proper check routines responsible for the
54 * argument type. So these language implement typically only one generic
55 * fieldtype they register with the forms library using this call.
57 * For that purpose we have extended the fieldtype struc by a new element
58 * that gets the arguments from a single struct passed by the caller.
63 /*---------------------------------------------------------------------------
65 | Function : static void *Generic_This_Type( void * arg )
67 | Description : We interpret the passed arg just as a handle the
68 | calling language uses to keep track of its allocated
69 | argument structures. We can simply copy it back.
71 | Return Values : Pointer to argument structure
72 +--------------------------------------------------------------------------*/
74 Generic_This_Type(void *arg)
79 /*---------------------------------------------------------------------------
81 | Function : FIELDTYPE *_nc_generic_fieldtype(
82 | bool (* const field_check)(FIELD *,const void *),
83 | bool (* const char_check) (int, const void *),
84 | bool (*const next)(FORM*,FIELD*,const void*),
85 | bool (*const prev)(FORM*,FIELD*,const void*),
86 | void (*freecallback)(void*))
88 | Description : Create a new fieldtype. The application programmer must
89 | write a field_check and a char_check function and give
90 | them as input to this call. A callback to allow the
91 | release of the allocated memory must also be provided.
92 | For generic field types, we provide some more
93 | information about the field as parameters.
95 | If an error occurs, errno is set to
96 | E_BAD_ARGUMENT - invalid arguments
97 | E_SYSTEM_ERROR - system error (no memory)
99 | Return Values : Fieldtype pointer or NULL if error occurred
100 +--------------------------------------------------------------------------*/
101 NCURSES_EXPORT(FIELDTYPE *)
102 _nc_generic_fieldtype(bool (*const field_check) (FORM*, FIELD *, const void *),
103 bool (*const char_check) (int, FORM*, FIELD*, const void *),
104 bool (*const next)(FORM*, FIELD*,const void*),
105 bool (*const prev)(FORM*, FIELD*,const void*),
106 void (*freecallback)(void*))
108 int code = E_SYSTEM_ERROR;
109 FIELDTYPE* res = (FIELDTYPE*)0;
111 T((T_CALLED("_nc_generic_fieldtype(%p,%p,%p,%p,%p)"),
112 field_check, char_check, next, prev, freecallback));
114 if (field_check || char_check)
116 res = typeMalloc(FIELDTYPE,1);
119 *res = *_nc_Default_FieldType;
120 res->status |= (_HAS_ARGS | _GENERIC);
121 res->fieldcheck.gfcheck = field_check;
122 res->charcheck.gccheck = char_check;
123 res->genericarg = Generic_This_Type;
124 res->freearg = freecallback;
125 res->enum_next.gnext = next;
126 res->enum_prev.gprev = prev;
131 code = E_BAD_ARGUMENT;
136 returnFieldType(res);
140 /*---------------------------------------------------------------------------
141 | Facility : libnform
142 | Function : static TypeArgument *GenericArgument(
143 | const FIELDTYPE* typ,
144 | int (*argiterator)(void**),
147 | Description : The iterator callback must browse through all fieldtype
148 | parameters that have an argument associated with the
149 | type. The iterator returns 1 if the operation to get
150 | the next element was successfull, 0 otherwise. If the
151 | iterator could move to the next argument, it fills
152 | the void* pointer representing the argument into the
153 | location provided as argument to the iterator.
154 | The err reference is used to keep track of errors.
156 | Return Values : Pointer to argument structure
157 +--------------------------------------------------------------------------*/
159 GenericArgument(const FIELDTYPE *typ,
160 int (*argiterator)(void**), int *err)
162 TypeArgument *res = (TypeArgument *)0;
164 if (typ!=0 && (typ->status & _HAS_ARGS) != 0 && err!=0 && argiterator != 0)
166 if (typ->status & _LINKED_TYPE)
168 /* Composite fieldtypes keep track internally of their own memory */
169 TypeArgument* p = typeMalloc(TypeArgument,1);
172 p->left = GenericArgument(typ->left, argiterator, err);
173 p->right = GenericArgument(typ->right, argiterator, err);
181 assert(typ->genericarg != (void*)0);
182 if (typ->genericarg == 0)
187 int valid = argiterator(&argp);
188 if (valid==0 || argp==0 ||
189 !(res = (TypeArgument*)typ->genericarg(argp)))
199 /*---------------------------------------------------------------------------
200 | Facility : libnform
201 | Function : int _nc_set_generic_fieldtype(
204 | int (*argiterator)(void**))
206 | Description : Assign the fieldtype to the field and use the iterator
207 | mechanism to get the arguments when a check is
210 | Return Values : E_OK if all went well
211 | E_SYSTEM_ERROR if an error occurred
212 +--------------------------------------------------------------------------*/
214 _nc_set_generic_fieldtype(FIELD *field,
216 int (*argiterator)(void**))
218 int code = E_SYSTEM_ERROR;
223 if (field && field->type)
224 _nc_Free_Type(field);
231 /* The precondition is that the iterator is reset */
232 field->arg = (void*)GenericArgument(field->type,argiterator,&err);
236 _nc_Free_Argument(field->type, (TypeArgument*)(field->arg));
237 field->type = (FIELDTYPE*)0;
238 field->arg = (void*)0;
250 field->arg = (void*)0;
257 /*---------------------------------------------------------------------------
258 | Facility : libnform
259 | Function : WINDOW* _nc_form_cursor(
261 | int *pRow, int *pCol)
263 | Description : Get the current position of the form cursor position
264 | We also return the field window
266 | Return Values : The fields Window or NULL on error
267 +--------------------------------------------------------------------------*/
268 NCURSES_EXPORT(WINDOW*)
269 _nc_form_cursor(const FORM* form, int* pRow, int* pCol)
271 int code = E_SYSTEM_ERROR;
272 WINDOW* res = (WINDOW*)0;
274 if (!(form==0 || pRow==0 || pCol==0))
276 *pRow = form->currow;
277 *pCol = form->curcol;
287 /* fty_generic.c ends here */