form/fty_generic.c

   1 /****************************************************************************
   2  * Copyright (c) 2008 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.1 2008/11/18 08:50:04 juergen 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
  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 void *),
 104                       bool (*const next)(FORM*, FIELD*,const void*),
 105                       bool (*const prev)(FORM*, FIELD*,const void*),
 106                       void (*freecallback)(void*))
 107 {
 108     int code = E_SYSTEM_ERROR;
 109     FIELDTYPE* res = (FIELDTYPE*)0;
 110
 111     T((T_CALLED("_nc_generic_fieldtype(%p,%p,%p,%p,%p)"),
 112        field_check, char_check, next, prev, freecallback));
 113
 114     if (field_check || char_check)
 115     {
 116       res = typeMalloc(FIELDTYPE,1);
 117       if (res)
 118       {
 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;
 127         code = E_OK;
 128       }
 129     }
 130     else
 131       code = E_BAD_ARGUMENT;
 132
 133     if (E_OK != code)
 134       SET_ERROR(code);
 135
 136     returnFieldType(res);
 137 }
 138
 139
 140 /*---------------------------------------------------------------------------
 141 |   Facility      :  libnform
 142 |   Function      :  static TypeArgument *GenericArgument(
 143 |                      const FIELDTYPE* typ,
 144 |                      int (*argiterator)(void**),
 145 |                      int* err)
 146 |
 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.
 155 |
 156 |   Return Values :  Pointer to argument structure
 157 +--------------------------------------------------------------------------*/
 158 static TypeArgument*
 159 GenericArgument(const FIELDTYPE *typ,
 160                 int (*argiterator)(void**), int *err)
 161 {
 162   TypeArgument *res = (TypeArgument *)0;
 163
 164   if (typ!=0 && (typ->status & _HAS_ARGS) != 0 && err!=0 && argiterator != 0)
 165   {
 166     if (typ->status & _LINKED_TYPE)
 167     {
 168       /* Composite fieldtypes keep track internally of their own memory */
 169       TypeArgument* p = typeMalloc(TypeArgument,1);
 170       if (p)
 171       {
 172         p->left  = GenericArgument(typ->left,  argiterator, err);
 173         p->right = GenericArgument(typ->right, argiterator, err);
 174         return p;
 175       }
 176       else
 177         *err += 1;
 178     }
 179     else
 180     {
 181       assert(typ->genericarg != (void*)0);
 182       if (typ->genericarg == 0)
 183         *err += 1;
 184       else
 185         {
 186           void* argp;
 187           int valid = argiterator(&argp);
 188           if (valid==0 || argp==0 ||
 189               !(res = (TypeArgument*)typ->genericarg(argp)))
 190             {
 191               *err += 1;
 192             }
 193         }
 194     }
 195   }
 196   return res;
 197 }
 198
 199 /*---------------------------------------------------------------------------
 200 |   Facility      :  libnform
 201 |   Function      :  int _nc_set_generic_fieldtype(
 202 |                      FIELD* field,
 203 |                      FIELDTYPE* ftyp,
 204 |                      int (*argiterator)(void**))
 205 |
 206 |   Description   :  Assign the fieldtype to the field and use the iterator
 207 |                    mechanism to get the arguments when a check is
 208 |                    performed.
 209 |
 210 |   Return Values :  E_OK if all went well
 211 |                    E_SYSTEM_ERROR if an error occurred
 212 +--------------------------------------------------------------------------*/
 213 NCURSES_EXPORT(int)
 214 _nc_set_generic_fieldtype(FIELD *field,
 215                           FIELDTYPE* ftyp,
 216                           int (*argiterator)(void**))
 217 {
 218   int code = E_SYSTEM_ERROR;
 219   int err = 0;
 220
 221   if (field)
 222   {
 223       if (field && field->type)
 224         _nc_Free_Type(field);
 225
 226       field->type = ftyp;
 227       if (ftyp)
 228       {
 229         if (argiterator)
 230         {
 231           /* The precondition is that the iterator is reset */
 232           field->arg  = (void*)GenericArgument(field->type,argiterator,&err);
 233
 234           if (err)
 235             {
 236               _nc_Free_Argument(field->type, (TypeArgument*)(field->arg));
 237               field->type = (FIELDTYPE*)0;
 238               field->arg  = (void*)0;
 239             }
 240           else
 241             {
 242               code = E_OK;
 243               if (field->type)
 244                 field->type->ref++;
 245             }
 246         }
 247       }
 248       else
 249       {
 250         field->arg = (void*)0;
 251         code = E_OK;
 252       }
 253     }
 254     return code;
 255 }
 256
 257 /*---------------------------------------------------------------------------
 258 |   Facility      :  libnform
 259 |   Function      :  WINDOW* _nc_form_cursor(
 260 |                      FORM* form,
 261 |                      int *pRow, int *pCol)
 262 |
 263 |   Description   :  Get the current position of the form cursor position
 264 |                    We also return the field window
 265 |
 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)
 270 {
 271   int code = E_SYSTEM_ERROR;
 272   WINDOW* res = (WINDOW*)0;
 273
 274   if (!(form==0 || pRow==0 || pCol==0))
 275   {
 276       *pRow = form->currow;
 277       *pCol = form->curcol;
 278       res   = form->w;
 279       code  = E_OK;
 280   }
 281   if (code != E_OK)
 282     SET_ERROR(code);
 283   return res;
 284 }
 285
 286
 287 /* fty_generic.c ends here */