form/fty_generic.c

   1 /****************************************************************************
   2  * Copyright (c) 2008-2012,2016 Free Software Foundation, Inc.              *
   3  *                                                                          *
   4  * Permission is hereby granted, free of charge, to any person obtaining a  *
   5  * copy of this software and associated documentation files (the            *
   6  * "Software"), to deal in the Software without restriction, including      *
   7  * without limitation the rights to use, copy, modify, merge, publish,      *
   8  * distribute, distribute with modifications, sublicense, and/or sell       *
   9  * copies of the Software, and to permit persons to whom the Software is    *
  10  * furnished to do so, subject to the following conditions:                 *
  11  *                                                                          *
  12  * The above copyright notice and this permission notice shall be included  *
  13  * in all copies or substantial portions of the Software.                   *
  14  *                                                                          *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
  16  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
  17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
  18  * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
  19  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
  20  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
  21  * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
  22  *                                                                          *
  23  * Except as contained in this notice, the name(s) of the above copyright   *
  24  * holders shall not be used in advertising or otherwise to promote the     *
  25  * sale, use or other dealings in this Software without prior written       *
  26  * authorization.                                                           *
  27  ****************************************************************************/
  28
  29 /***************************************************************************
  30 *                                                                          *
  31 *  Author : Juergen Pfeifer                                                *
  32 *                                                                          *
  33 ***************************************************************************/
  34
  35 #include "form.priv.h"
  36
  37 MODULE_ID("$Id: fty_generic.c,v 1.7 2016/01/23 21:32:00 tom Exp $")
  38
  39 /*
  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.
  56  *
  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.
  59  *
  60  */
  61 #if NCURSES_INTEROP_FUNCS
  62
  63 /*---------------------------------------------------------------------------
  64 |   Facility      :  libnform
  65 |   Function      :  static void *Generic_This_Type( void * arg )
  66 |
  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.
  70 |
  71 |   Return Values :  Pointer to argument structure
  72 +--------------------------------------------------------------------------*/
  73 static void *
  74 Generic_This_Type(void *arg)
  75 {
  76   return (arg);
  77 }
  78
  79 /*---------------------------------------------------------------------------
  80 |   Facility      :  libnform
  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*))
  87 |
  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.
  94 |
  95 |                    If an error occurs, errno is set to
  96 |                       E_BAD_ARGUMENT  - invalid arguments
  97 |                       E_SYSTEM_ERROR  - system error (no memory)
  98 |
  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
 104                                                 void *),
 105                       bool (*const next) (FORM *, FIELD *, const void *),
 106                       bool (*const prev) (FORM *, FIELD *, const void *),
 107                       void (*freecallback) (void *))
 108 {
 109   int code = E_SYSTEM_ERROR;
 110   FIELDTYPE *res = (FIELDTYPE *)0;
 111
 112   T((T_CALLED("_nc_generic_fieldtype(%p,%p,%p,%p,%p)"),
 113      TR_FUNC(field_check),
 114      TR_FUNC(char_check),
 115      TR_FUNC(next),
 116      TR_FUNC(prev),
 117      TR_FUNC(freecallback)));
 118
 119   if (field_check || char_check)
 120     {
 121       res = typeMalloc(FIELDTYPE, 1);
 122
 123       if (res)
 124         {
 125           *res = *_nc_Default_FieldType;
 126           SetStatus(res, (_HAS_ARGS | _GENERIC));
 127           res->fieldcheck.gfcheck = field_check;
 128           res->charcheck.gccheck = char_check;
 129           res->genericarg = Generic_This_Type;
 130           res->freearg = freecallback;
 131           res->enum_next.gnext = next;
 132           res->enum_prev.gprev = prev;
 133           code = E_OK;
 134         }
 135     }
 136   else
 137     code = E_BAD_ARGUMENT;
 138
 139   if (E_OK != code)
 140     SET_ERROR(code);
 141
 142   returnFieldType(res);
 143 }
 144
 145 /*---------------------------------------------------------------------------
 146 |   Facility      :  libnform
 147 |   Function      :  static TypeArgument *GenericArgument(
 148 |                      const FIELDTYPE* typ,
 149 |                      int (*argiterator)(void**),
 150 |                      int* err)
 151 |
 152 |   Description   :  The iterator callback must browse through all fieldtype
 153 |                    parameters that have an argument associated with the
 154 |                    type. The iterator returns 1 if the operation to get
 155 |                    the next element was successfull, 0 otherwise. If the
 156 |                    iterator could move to the next argument, it fills
 157 |                    the void* pointer representing the argument into the
 158 |                    location provided as argument to the iterator.
 159 |                    The err reference is used to keep track of errors.
 160 |
 161 |   Return Values :  Pointer to argument structure
 162 +--------------------------------------------------------------------------*/
 163 static TypeArgument *
 164 GenericArgument(const FIELDTYPE *typ,
 165                 int (*argiterator) (void **), int *err)
 166 {
 167   TypeArgument *res = (TypeArgument *)0;
 168
 169   if (typ != 0 && (typ->status & _HAS_ARGS) != 0 && err != 0 && argiterator != 0)
 170     {
 171       if (typ->status & _LINKED_TYPE)
 172         {
 173           /* Composite fieldtypes keep track internally of their own memory */
 174           TypeArgument *p = typeMalloc(TypeArgument, 1);
 175
 176           if (p)
 177             {
 178               p->left = GenericArgument(typ->left, argiterator, err);
 179               p->right = GenericArgument(typ->right, argiterator, err);
 180               return p;
 181             }
 182           else
 183             *err += 1;
 184         }
 185       else
 186         {
 187           assert(typ->genericarg != (void *)0);
 188           if (typ->genericarg == 0)
 189             *err += 1;
 190           else
 191             {
 192               void *argp;
 193               int valid = argiterator(&argp);
 194
 195               if (valid == 0 || argp == 0 ||
 196                   !(res = (TypeArgument *)typ->genericarg(argp)))
 197                 {
 198                   *err += 1;
 199                 }
 200             }
 201         }
 202     }
 203   return res;
 204 }
 205
 206 /*---------------------------------------------------------------------------
 207 |   Facility      :  libnform
 208 |   Function      :  int _nc_set_generic_fieldtype(
 209 |                      FIELD* field,
 210 |                      FIELDTYPE* ftyp,
 211 |                      int (*argiterator)(void**))
 212 |
 213 |   Description   :  Assign the fieldtype to the field and use the iterator
 214 |                    mechanism to get the arguments when a check is
 215 |                    performed.
 216 |
 217 |   Return Values :  E_OK if all went well
 218 |                    E_SYSTEM_ERROR if an error occurred
 219 +--------------------------------------------------------------------------*/
 220 NCURSES_EXPORT(int)
 221 _nc_set_generic_fieldtype(FIELD *field,
 222                           FIELDTYPE *ftyp,
 223                           int (*argiterator) (void **))
 224 {
 225   int code = E_SYSTEM_ERROR;
 226   int err = 0;
 227
 228   if (field)
 229     {
 230       if (field && field->type)
 231         _nc_Free_Type(field);
 232
 233       field->type = ftyp;
 234       if (ftyp)
 235         {
 236           if (argiterator)
 237             {
 238               /* The precondition is that the iterator is reset */
 239               field->arg = (void *)GenericArgument(field->type, argiterator, &err);
 240
 241               if (err)
 242                 {
 243                   _nc_Free_Argument(field->type, (TypeArgument *)(field->arg));
 244                   field->type = (FIELDTYPE *)0;
 245                   field->arg = (void *)0;
 246                 }
 247               else
 248                 {
 249                   code = E_OK;
 250                   if (field->type)
 251                     field->type->ref++;
 252                 }
 253             }
 254         }
 255       else
 256         {
 257           field->arg = (void *)0;
 258           code = E_OK;
 259         }
 260     }
 261   return code;
 262 }
 263
 264 /*---------------------------------------------------------------------------
 265 |   Facility      :  libnform
 266 |   Function      :  WINDOW* _nc_form_cursor(
 267 |                      FORM* form,
 268 |                      int *pRow, int *pCol)
 269 |
 270 |   Description   :  Get the current position of the form cursor position
 271 |                    We also return the field window
 272 |
 273 |   Return Values :  The fields Window or NULL on error
 274 +--------------------------------------------------------------------------*/
 275 NCURSES_EXPORT(WINDOW *)
 276 _nc_form_cursor(const FORM *form, int *pRow, int *pCol)
 277 {
 278   int code = E_SYSTEM_ERROR;
 279   WINDOW *res = (WINDOW *)0;
 280
 281   if (!(form == 0 || pRow == 0 || pCol == 0))
 282     {
 283       *pRow = form->currow;
 284       *pCol = form->curcol;
 285       res = form->w;
 286       code = E_OK;
 287     }
 288   if (code != E_OK)
 289     SET_ERROR(code);
 290   return res;
 291 }
 292
 293 #else
 294 extern void _nc_fty_generic(void);
 295 void
 296 _nc_fty_generic(void)
 297 {
 298 }
 299 #endif
 300
 301 /* fty_generic.c ends here */