1 /* FL module -- interface to Mark Overmars' FORMS Library. */

     2 

     3 /* This code works with FORMS version 2.2 (if you defined

     4    OBSOLETE_FORMS_CALLS), and 2.3.

     5    FORMS can be ftp'ed from ftp.cs.ruu.nl (131.211.80.17), directory

     6    /pub/SGI/FORMS. */

     7 

     8 /* A half-hearted attempt has been made to allow programs using this

     9  * module to exploit parallelism (through the threads module). No provisions

    10  * have been made for multiple threads to use this module at the same time,

    11  * though. So, a program with a forms thread and a non-forms thread will work

    12  * fine but a program with two threads using forms will probably crash (unless

    13  * the program takes precaution to ensure that only one thread can be in

    14  * this module at any time). This will have to be fixed some time.

    15  * (A fix will probably also have to synchronize with the gl module).

    16  */

    17 

    18 #include "Python.h"

    19 #include "forms.h"

    20 #include "structmember.h"

    21 

    22 /* Generic Forms Objects */

    23 

    24 typedef struct {

    25 	PyObject_HEAD

    26 	FL_OBJECT *ob_generic;

    27 	PyMethodDef *ob_methods;

    28 	PyObject *ob_callback;

    29 	PyObject *ob_callback_arg;

    30 } genericobject;

    31 

    32 static PyTypeObject GenericObjecttype;

    33 

    34 #define is_genericobject(g) ((g)->ob_type == &GenericObjecttype)

    35 

    36 /* List of all objects (XXX this should be a hash table on address...) */

    37 

    38 static PyObject *allgenerics = NULL;

    39 static int nfreeslots = 0;

    40 

    41 /* Add an object to the list of known objects */

    42 

    43 static void

    44 knowgeneric(genericobject *g)

    45 {

    46 	int i, n;

    47 	/* Create the list if it doesn't already exist */

    48 	if (allgenerics == NULL) {

    49 		allgenerics = PyList_New(0);

    50 		if (allgenerics == NULL) {

    51 			PyErr_Clear();

    52 			return; /* Too bad, live without allgenerics... */

    53 		}

    54 	}

    55 	if (nfreeslots > 0) {

    56 		/* Search the list for reusable slots (NULL items) */

    57 		/* XXX This can be made faster! */

    58 		n = PyList_Size(allgenerics);

    59 		for (i = 0; i < n; i++) {

    60 			if (PyList_GetItem(allgenerics, i) == NULL) {

    61 				Py_INCREF(g);

    62 				PyList_SetItem(allgenerics, i, (PyObject *)g);

    63 				nfreeslots--;

    64 				return;

    65 			}

    66 		}

    67 		/* Strange... no free slots found... */

    68 		nfreeslots = 0;

    69 	}

    70 	/* No free entries, append new item to the end */

    71 	PyList_Append(allgenerics, (PyObject *)g);

    72 }

    73 

    74 /* Find an object in the list of known objects */

    75 

    76 static genericobject *

    77 findgeneric(FL_OBJECT *generic)

    78 {

    79 	int i, n;

    80 	genericobject *g;

    81 	

    82 	if (allgenerics == NULL)

    83 		return NULL; /* No objects known yet */

    84 	n = PyList_Size(allgenerics);

    85 	for (i = 0; i < n; i++) {

    86 		g = (genericobject *)PyList_GetItem(allgenerics, i);

    87 		if (g != NULL && g->ob_generic == generic)

    88 			return g;

    89 	}

    90 	return NULL; /* Unknown object */

    91 }

    92 

    93 /* Remove an object from the list of known objects */

    94 

    95 static void

    96 forgetgeneric(genericobject *g)

    97 {

    98 	int i, n;

    99 	

   100 	Py_XDECREF(g->ob_callback);

   101 	g->ob_callback = NULL;

   102 	Py_XDECREF(g->ob_callback_arg);

   103 	g->ob_callback_arg = NULL;

   104 	if (allgenerics == NULL)

   105 		return; /* No objects known yet */

   106 	n = PyList_Size(allgenerics);

   107 	for (i = 0; i < n; i++) {

   108 		if (g == (genericobject *)PyList_GetItem(allgenerics, i)) {

   109 			PyList_SetItem(allgenerics, i, (PyObject *)NULL);

   110 			nfreeslots++;

   111 			break;

   112 		}

   113 	}

   114 }

   115 

   116 /* Called when a form is about to be freed --

   117    remove all the objects that we know about from it. */

   118 

   119 static void

   120 releaseobjects(FL_FORM *form)

   121 {

   122 	int i, n;

   123 	genericobject *g;

   124 	

   125 	if (allgenerics == NULL)

   126 		return; /* No objects known yet */

   127 	n = PyList_Size(allgenerics);

   128 	for (i = 0; i < n; i++) {

   129 		g = (genericobject *)PyList_GetItem(allgenerics, i);

   130 		if (g != NULL && g->ob_generic->form == form) {

   131 			fl_delete_object(g->ob_generic);

   132 			/* The object is now unreachable for

   133 			   do_forms and check_forms, so

   134 			   delete it from the list of known objects */

   135 			Py_XDECREF(g->ob_callback);

   136 			g->ob_callback = NULL;

   137 			Py_XDECREF(g->ob_callback_arg);

   138 			g->ob_callback_arg = NULL;

   139 			PyList_SetItem(allgenerics, i, (PyObject *)NULL);

   140 			nfreeslots++;

   141 		}

   142 	}

   143 }

   144 

   145 

   146 /* Methods of generic objects */

   147 

   148 static PyObject *

   149 generic_set_call_back(genericobject *g, PyObject *args)

   150 {

   151 	if (PyTuple_GET_SIZE(args) == 0) {

   152 		Py_XDECREF(g->ob_callback);

   153 		Py_XDECREF(g->ob_callback_arg);

   154 		g->ob_callback = NULL;

   155 		g->ob_callback_arg = NULL;

   156 	}

   157 	else {

   158         PyObject *a, *b;

   159         if (!PyArg_UnpackTuple(args, "set_call_back", 2, 2, &a, &b)

   160             return NULL;

   161 		Py_XDECREF(g->ob_callback);

   162 		Py_XDECREF(g->ob_callback_arg);

   163 		g->ob_callback = a;

   164 		Py_INCREF(g->ob_callback);

   165 		g->ob_callback_arg = b;

   166 		Py_INCREF(g->ob_callback_arg);

   167 	}

   168 	Py_INCREF(Py_None);

   169 	return Py_None;

   170 }

   171 

   172 static PyObject *

   173 generic_call(genericobject *g, void (*func)(FL_OBJECT *))

   174 {

   175 	(*func)(g->ob_generic);

   176 	Py_INCREF(Py_None);

   177 	return Py_None;

   178 }

   179 

   180 static PyObject *

   181 generic_delete_object(genericobject *g)

   182 {

   183 	PyObject *res;

   184 	res = generic_call(g, fl_delete_object);

   185 	if (res != NULL)

   186 		forgetgeneric(g);

   187 	return res;

   188 }

   189 

   190 static PyObject *

   191 generic_show_object(genericobject *g)

   192 {

   193 	return generic_call(g, fl_show_object);

   194 }

   195 

   196 static PyObject *

   197 generic_hide_object(genericobject *g)

   198 {

   199 	return generic_call(g, fl_hide_object);

   200 }

   201 

   202 static PyObject *

   203 generic_redraw_object(genericobject *g)

   204 {

   205 	return generic_call(g, fl_redraw_object);

   206 }

   207 

   208 #ifdef OBSOLETE_FORMS_CALLS

   209  

   210  /* (un)freeze_object() are obsolete in FORMS 2.2 and unsupported

   211     in 2.3.  Since there's no foolproof way to tell which version we're

   212     using, we omit them unconditionally. */

   213  

   214 static PyObject *

   215 generic_freeze_object(genericobject *g)

   216 {

   217 	return generic_call(g, fl_freeze_object);

   218 }

   219 

   220 static PyObject *

   221 generic_unfreeze_object(genericobject *g)

   222 {

   223 	return generic_call(g, fl_unfreeze_object);

   224 }

   225 

   226 #endif /* OBSOLETE_FORMS_CALLS */

   227 

   228 static PyObject *

   229 generic_activate_object(genericobject *g)

   230 {

   231 	return generic_call(g, fl_activate_object);

   232 }

   233 

   234 static PyObject *

   235 generic_deactivate_object(genericobject *g)

   236 {

   237 	return generic_call(g, fl_deactivate_object);

   238 }

   239 

   240 static PyObject *

   241 generic_set_object_shortcut(genericobject *g, PyObject *args)

   242 {

   243 	char *str;

   244 	if (!PyArg_ParseTuple(args, "s:set_object_shortcut", &str))

   245 		return NULL;

   246 	fl_set_object_shortcut(g->ob_generic, str);

   247 	Py_INCREF(Py_None);

   248 	return Py_None;

   249 }

   250 

   251 static PyMethodDef generic_methods[] = {

   252 	{"set_call_back",	(PyCFunction)generic_set_call_back, METH_VARARGS},

   253 	{"delete_object",	(PyCFunction)generic_delete_object, METH_NOARGS},

   254 	{"show_object",		(PyCFunction)generic_show_object, METH_NOARGS},

   255 	{"hide_object",		(PyCFunction)generic_hide_object, METH_NOARGS},

   256 	{"redraw_object",	(PyCFunction)generic_redraw_object, METH_NOARGS},

   257 #ifdef OBSOLETE_FORMS_CALLS

   258 	{"freeze_object",	(PyCFunction)generic_freeze_object, METH_NOARGS},

   259 	{"unfreeze_object",	(PyCFunction)generic_unfreeze_object, METH_NOARGS},

   260 #endif

   261 	{"activate_object",	(PyCFunction)generic_activate_object, METH_NOARGS},

   262 	{"deactivate_object",	(PyCFunction)generic_deactivate_object, METH_NOARGS},

   263 	{"set_object_shortcut",	(PyCFunction)generic_set_object_shortcut, METH_VARARGS},

   264 	{NULL,			NULL}		/* sentinel */

   265 };

   266 

   267 static void

   268 generic_dealloc(genericobject *g)

   269 {

   270 	fl_free_object(g->ob_generic);

   271 	Py_XDECREF(g->ob_callback);

   272 	Py_XDECREF(g->ob_callback_arg);

   273 	PyObject_Del(g);

   274 }

   275 

   276 #define OFF(x) offsetof(FL_OBJECT, x)

   277 

   278 static struct memberlist generic_memberlist[] = {

   279 	{"objclass",	T_INT,		OFF(objclass),	RO},

   280 	{"type",	T_INT,		OFF(type),	RO},

   281 	{"boxtype",	T_INT,		OFF(boxtype)},

   282 	{"x",		T_FLOAT,	OFF(x)},

   283 	{"y",		T_FLOAT,	OFF(y)},

   284 	{"w",		T_FLOAT,	OFF(w)},

   285 	{"h",		T_FLOAT,	OFF(h)},

   286 	{"col1",	T_INT,		OFF(col1)},

   287 	{"col2",	T_INT,		OFF(col2)},

   288 	{"align",	T_INT,		OFF(align)},

   289 	{"lcol",	T_INT,		OFF(lcol)},

   290 	{"lsize",	T_FLOAT,	OFF(lsize)},

   291 	/* "label" is treated specially! */

   292 	{"lstyle",	T_INT,		OFF(lstyle)},

   293 	{"pushed",	T_INT,		OFF(pushed),	RO},

   294 	{"focus",	T_INT,		OFF(focus),	RO},

   295 	{"belowmouse",	T_INT,		OFF(belowmouse),RO},

   296 /*	{"frozen",	T_INT,		OFF(frozen),	RO},	*/

   297 	{"active",	T_INT,		OFF(active)},

   298 	{"input",	T_INT,		OFF(input)},

   299 	{"visible",	T_INT,		OFF(visible),	RO},

   300 	{"radio",	T_INT,		OFF(radio)},

   301 	{"automatic",	T_INT,		OFF(automatic)},

   302 	{NULL}	/* Sentinel */

   303 };

   304 

   305 #undef OFF

   306 

   307 static PyObject *

   308 generic_getattr(genericobject *g, char *name)

   309 {

   310 	PyObject *meth;

   311 

   312 	/* XXX Ought to special-case name "__methods__" */

   313 	if (g-> ob_methods) {

   314 		meth = Py_FindMethod(g->ob_methods, (PyObject *)g, name);

   315 		if (meth != NULL) return meth;

   316 		PyErr_Clear();

   317 	}

   318 

   319 	meth = Py_FindMethod(generic_methods, (PyObject *)g, name);

   320 	if (meth != NULL)

   321 		return meth;

   322 	PyErr_Clear();

   323 

   324 	/* "label" is an exception, getmember only works for char pointers,

   325 	   not for char arrays */

   326 	if (strcmp(name, "label") == 0)

   327 		return PyString_FromString(g->ob_generic->label);

   328 

   329 	return PyMember_Get((char *)g->ob_generic, generic_memberlist, name);

   330 }

   331 

   332 static int

   333 generic_setattr(genericobject *g, char *name, PyObject *v)

   334 {

   335 	int ret;

   336 

   337 	if (v == NULL) {

   338 		PyErr_SetString(PyExc_TypeError,

   339 				"can't delete forms object attributes");

   340 		return -1;

   341 	}

   342 

   343 	/* "label" is an exception: setmember doesn't set strings;

   344 	   and FORMS wants you to call a function to set the label */

   345 	if (strcmp(name, "label") == 0) {

   346 		if (!PyString_Check(v)) {

   347 			PyErr_SetString(PyExc_TypeError,

   348 					"label attr must be string");

   349 			return -1;

   350 		}

   351 		fl_set_object_label(g->ob_generic, PyString_AsString(v));

   352 		return 0;

   353 	}

   354 

   355 	ret = PyMember_Set((char *)g->ob_generic, generic_memberlist, name, v);

   356 

   357 	/* Rather than calling all the various set_object_* functions,

   358 	   we call fl_redraw_object here.  This is sometimes redundant

   359 	   but I doubt that's a big problem */

   360 	if (ret == 0)

   361 		fl_redraw_object(g->ob_generic);

   362 

   363 	return ret;

   364 }

   365 

   366 static PyObject *

   367 generic_repr(genericobject *g)

   368 {

   369 	char buf[100];

   370 	PyOS_snprintf(buf, sizeof(buf), "<FORMS_object at %p, objclass=%d>",

   371 		      g, g->ob_generic->objclass);

   372 	return PyString_FromString(buf);

   373 }

   374 

   375 static PyTypeObject GenericObjecttype = {

   376 	PyObject_HEAD_INIT(&PyType_Type)

   377 	0,				/*ob_size*/

   378 	"fl.FORMS_object",		/*tp_name*/

   379 	sizeof(genericobject),		/*tp_size*/

   380 	0,				/*tp_itemsize*/

   381 	/* methods */

   382 	(destructor)generic_dealloc,	/*tp_dealloc*/

   383 	0,				/*tp_print*/

   384 	(getattrfunc)generic_getattr,	/*tp_getattr*/

   385 	(setattrfunc)generic_setattr,	/*tp_setattr*/

   386 	0,				/*tp_compare*/

   387 	(reprfunc)generic_repr,		/*tp_repr*/

   388 };

   389 

   390 static PyObject *

   391 newgenericobject(FL_OBJECT *generic, PyMethodDef *methods)

   392 {

   393 	genericobject *g;

   394 	g = PyObject_New(genericobject, &GenericObjecttype);

   395 	if (g == NULL)

   396 		return NULL;

   397 	g-> ob_generic = generic;

   398 	g->ob_methods = methods;

   399 	g->ob_callback = NULL;

   400 	g->ob_callback_arg = NULL;

   401 	knowgeneric(g);

   402 	return (PyObject *)g;

   403 }

   404 

   405 /**********************************************************************/

   406 /* Some common calling sequences */

   407 

   408 /* void func (object, float) */

   409 static PyObject *

   410 call_forms_INf (void (*func)(FL_OBJECT *, float), FL_OBJECT *obj, PyObject *args)

   411 {

   412 	float parameter;

   413 

   414 	if (!PyArg_Parse(args, "f", &parameter)) return NULL;

   415 

   416 	(*func) (obj, parameter);

   417 

   418 	Py_INCREF(Py_None);

   419 	return Py_None;

   420 }

   421 

   422 /* void func (object, float) */

   423 static PyObject *

   424 call_forms_INfINf (void (*func)(FL_OBJECT *, float, float), FL_OBJECT *obj, PyObject *args)

   425 {

   426 	float par1, par2;

   427 

   428 	if (!PyArg_Parse(args, "(ff)", &par1, &par2)) return NULL;

   429 

   430 	(*func) (obj, par1, par2);

   431 

   432 	Py_INCREF(Py_None);

   433 	return Py_None;

   434 }

   435 

   436 /* void func (object, int) */

   437 static PyObject *

   438 call_forms_INi (void (*func)(FL_OBJECT *, int), FL_OBJECT *obj, PyObject *args)

   439 {

   440 	int parameter;

   441 

   442 	if (!PyArg_Parse(args, "i", &parameter)) return NULL;

   443 

   444 	(*func) (obj, parameter);

   445 

   446 	Py_INCREF(Py_None);

   447 	return Py_None;

   448 }

   449 

   450 /* void func (object, char) */

   451 static PyObject *

   452 call_forms_INc (void (*func)(FL_OBJECT *, int), FL_OBJECT *obj, PyObject *args)

   453 {

   454 	char *a;

   455 

   456 	if (!PyArg_Parse(args, "s", &a)) return NULL;

   457 

   458 	(*func) (obj, a[0]);

   459 

   460 	Py_INCREF(Py_None);

   461 	return Py_None;

   462 }

   463 

   464 /* void func (object, string) */

   465 static PyObject *

   466 call_forms_INstr (void (*func)(FL_OBJECT *, char *), FL_OBJECT *obj, PyObject *args)

   467 {

   468 	char *a;

   469 

   470 	if (!PyArg_Parse(args, "s", &a)) return NULL;

   471 

   472 	(*func) (obj, a);

   473 

   474 	Py_INCREF(Py_None);

   475 	return Py_None;

   476 }

   477 

   478 

   479 /* void func (object, int, string) */

   480 static PyObject *

   481 call_forms_INiINstr (void (*func)(FL_OBJECT *, int, char *), FL_OBJECT *obj, PyObject *args)

   482 {

   483 	char *b;

   484 	int a;

   485 	

   486 	if (!PyArg_Parse(args, "(is)", &a, &b)) return NULL;

   487 	

   488 	(*func) (obj, a, b);

   489 	

   490 	Py_INCREF(Py_None);

   491 	return Py_None;

   492 }

   493 

   494 #ifdef UNUSED

   495 /* void func (object, int, int) */

   496 static PyObject *

   497 call_forms_INiINi (void (*func)(FL_OBJECT *, int, int), FL_OBJECT *obj, PyObject *args)

   498 {

   499 	int par1, par2;

   500 	

   501 	if (!PyArg_Parse(args, "(ii)", &par1, &par2)) return NULL;

   502 	

   503 	(*func) (obj, par1, par2);

   504 	

   505 	Py_INCREF(Py_None);

   506 	return Py_None;

   507 }

   508 #endif

   509 

   510 /* int func (object) */

   511 static PyObject *

   512 call_forms_Ri (int (*func)(FL_OBJECT *), FL_OBJECT *obj)

   513 {

   514 	int retval;

   515 

   516 	retval = (*func) (obj);

   517 

   518 	return PyInt_FromLong ((long) retval);

   519 }

   520 

   521 /* char * func (object) */

   522 static PyObject *

   523 call_forms_Rstr (char * (*func)(FL_OBJECT *), FL_OBJECT *obj)

   524 {

   525 	char *str;

   526 

   527 	str = (*func) (obj);

   528 

   529 	if (str == NULL) {

   530 		Py_INCREF(Py_None);

   531 		return Py_None;

   532 	}

   533 	return PyString_FromString (str);

   534 }

   535 

   536 /* int func (object) */

   537 static PyObject *

   538 call_forms_Rf (float (*func)(FL_OBJECT *), FL_OBJECT *obj)

   539 {

   540 	float retval;

   541 

   542 	retval = (*func) (obj);

   543 

   544 	return PyFloat_FromDouble (retval);

   545 }

   546 

   547 static PyObject *

   548 call_forms_OUTfOUTf (void (*func)(FL_OBJECT *, float *, float *), FL_OBJECT *obj)

   549 {

   550 	float f1, f2;

   551 

   552 	(*func) (obj, &f1, &f2);

   553 

   554 	return Py_BuildValue("(ff)", f1, f2);

   555 }

   556 

   557 #ifdef UNUSED

   558 static PyObject *

   559 call_forms_OUTf (void (*func)(FL_OBJECT *, float *), FL_OBJECT *obj)

   560 {

   561 	float f;

   562 

   563 	(*func) (obj, &f);

   564 

   565 	return PyFloat_FromDouble (f);

   566 }

   567 #endif

   568 

   569 /**********************************************************************/

   570 /* Class : browser */

   571 

   572 static PyObject *

   573 set_browser_topline(genericobject *g, PyObject *args)

   574 {

   575 	return call_forms_INi (fl_set_browser_topline, g-> ob_generic, args);

   576 }

   577 

   578 static PyObject *

   579 clear_browser(genericobject *g)

   580 {

   581 	return generic_call (g, fl_clear_browser);

   582 }

   583 

   584 static PyObject *

   585 add_browser_line (genericobject *g, PyObject *args)

   586 {

   587 	return call_forms_INstr (fl_add_browser_line, g-> ob_generic, args);

   588 }

   589 

   590 static PyObject *

   591 addto_browser (genericobject *g, PyObject *args)

   592 {

   593 	return call_forms_INstr (fl_addto_browser, g-> ob_generic, args);

   594 }

   595 

   596 static PyObject *

   597 insert_browser_line (genericobject *g, PyObject *args)

   598 {

   599 	return call_forms_INiINstr (fl_insert_browser_line,

   600 				    g-> ob_generic, args);

   601 }

   602 

   603 static PyObject *

   604 delete_browser_line (genericobject *g, PyObject *args)

   605 {

   606 	return call_forms_INi (fl_delete_browser_line, g-> ob_generic, args);

   607 }

   608 

   609 static PyObject *

   610 replace_browser_line (genericobject *g, PyObject *args)

   611 {

   612 	return call_forms_INiINstr (fl_replace_browser_line,

   613 				    g-> ob_generic, args);

   614 }

   615 

   616 static PyObject *

   617 get_browser_line(genericobject *g, PyObject *args)

   618 {

   619 	int i;

   620 	char *str;

   621 

   622 	if (!PyArg_Parse(args, "i", &i))

   623 		return NULL;

   624 

   625 	str = fl_get_browser_line (g->ob_generic, i);

   626 

   627 	if (str == NULL) {

   628 		Py_INCREF(Py_None);

   629 		return Py_None;

   630 	}

   631 	return PyString_FromString (str);

   632 }

   633 

   634 static PyObject *

   635 load_browser (genericobject *g, PyObject *args)

   636 {

   637 	/* XXX strictly speaking this is wrong since fl_load_browser

   638 	   XXX returns int, not void */

   639 	return call_forms_INstr (fl_load_browser, g-> ob_generic, args);

   640 }

   641 

   642 static PyObject *

   643 get_browser_maxline(genericobject *g)

   644 {

   645 	return call_forms_Ri (fl_get_browser_maxline, g-> ob_generic);

   646 }

   647 

   648 static PyObject *

   649 select_browser_line (genericobject *g, PyObject *args)

   650 {

   651 	return call_forms_INi (fl_select_browser_line, g-> ob_generic, args);

   652 }

   653 

   654 static PyObject *

   655 deselect_browser_line (genericobject *g, PyObject *args)

   656 {

   657 	return call_forms_INi (fl_deselect_browser_line, g-> ob_generic, args);

   658 }

   659 

   660 static PyObject *

   661 deselect_browser (genericobject *g)

   662 {

   663 	return generic_call (g, fl_deselect_browser);

   664 }

   665 

   666 static PyObject *

   667 isselected_browser_line (genericobject *g, PyObject *args)

   668 {

   669 	int i, j;

   670 	

   671 	if (!PyArg_Parse(args, "i", &i))

   672 		return NULL;

   673 	

   674 	j = fl_isselected_browser_line (g->ob_generic, i);

   675 	

   676 	return PyInt_FromLong (j);

   677 }

   678 

   679 static PyObject *

   680 get_browser (genericobject *g)

   681 {

   682 	return call_forms_Ri (fl_get_browser, g-> ob_generic);

   683 }

   684 

   685 static PyObject *

   686 set_browser_fontsize (genericobject *g, PyObject *args)

   687 {

   688 	return call_forms_INf (fl_set_browser_fontsize, g-> ob_generic, args);

   689 }

   690 

   691 static PyObject *

   692 set_browser_fontstyle (genericobject *g, PyObject *args)

   693 {

   694 	return call_forms_INi (fl_set_browser_fontstyle, g-> ob_generic, args);

   695 }

   696 

   697 static PyObject *

   698 set_browser_specialkey (genericobject *g, PyObject *args)

   699 {

   700 	return call_forms_INc(fl_set_browser_specialkey, g-> ob_generic, args);

   701 }

   702 

   703 static PyMethodDef browser_methods[] = {

   704 	{"set_browser_topline",		(PyCFunction)set_browser_topline,

   705 	 METH_OLDARGS},

   706 	{"clear_browser",		(PyCFunction)clear_browser,

   707 	 METH_NOARGS},

   708 	{"add_browser_line",		(PyCFunction)add_browser_line,

   709 	 METH_OLDARGS},

   710 	{"addto_browser",		(PyCFunction)addto_browser,

   711 	 METH_OLDARGS},

   712 	{"insert_browser_line",		(PyCFunction)insert_browser_line,

   713 	 METH_OLDARGS},

   714 	{"delete_browser_line",		(PyCFunction)delete_browser_line,

   715 	 METH_OLDARGS},

   716 	{"replace_browser_line",	(PyCFunction)replace_browser_line,

   717 	 METH_OLDARGS},

   718 	{"get_browser_line",		(PyCFunction)get_browser_line,

   719 	 METH_OLDARGS},

   720 	{"load_browser",		(PyCFunction)load_browser,

   721 	 METH_OLDARGS},

   722 	{"get_browser_maxline",		(PyCFunction)get_browser_maxline,

   723 	 METH_NOARGS,}

   724 	{"select_browser_line",		(PyCFunction)select_browser_line,

   725 	 METH_OLDARGS},

   726 	{"deselect_browser_line",	(PyCFunction)deselect_browser_line,

   727 	 METH_OLDARGS},

   728 	{"deselect_browser",		(PyCFunction)deselect_browser,

   729 	 METH_NOARGS,}

   730 	{"isselected_browser_line",	(PyCFunction)isselected_browser_line,

   731 	 METH_OLDARGS},

   732 	{"get_browser",			(PyCFunction)get_browser,

   733 	 METH_NOARGS,}

   734 	{"set_browser_fontsize",	(PyCFunction)set_browser_fontsize,

   735 	 METH_OLDARGS},

   736 	{"set_browser_fontstyle",	(PyCFunction)set_browser_fontstyle,

   737 	 METH_OLDARGS},

   738 	{"set_browser_specialkey",	(PyCFunction)set_browser_specialkey,

   739 	 METH_OLDARGS},

   740 	{NULL,				NULL}		/* sentinel */

   741 };

   742 

   743 /* Class: button */

   744 

   745 static PyObject *

   746 set_button(genericobject *g, PyObject *args)

   747 {

   748 	return call_forms_INi (fl_set_button, g-> ob_generic, args);

   749 }

   750 

   751 static PyObject *

   752 get_button(genericobject *g)

   753 {

   754 	return call_forms_Ri (fl_get_button, g-> ob_generic);

   755 }

   756 

   757 static PyObject *

   758 get_button_numb(genericobject *g)

   759 {

   760 	return call_forms_Ri (fl_get_button_numb, g-> ob_generic);

   761 }

   762 

   763 static PyObject *

   764 set_button_shortcut(genericobject *g, PyObject *args)

   765 {

   766 	return call_forms_INstr (fl_set_button_shortcut, g-> ob_generic, args);

   767 }

   768 

   769 static PyMethodDef button_methods[] = {

   770 	{"set_button",		(PyCFunction)set_button, METH_OLDARGS},

   771 	{"get_button",		(PyCFunction)get_button, METH_NOARGS},

   772 	{"get_button_numb",	(PyCFunction)get_button_numb, METH_NOARGS},

   773 	{"set_button_shortcut",	(PyCFunction)set_button_shortcut, METH_OLDARGS},

   774 	{NULL,			NULL}		/* sentinel */

   775 };

   776 

   777 /* Class: choice */

   778 

   779 static PyObject *

   780 set_choice(genericobject *g, PyObject *args)

   781 {

   782 	return call_forms_INi (fl_set_choice, g-> ob_generic, args);

   783 }

   784 

   785 static PyObject *

   786 get_choice(genericobject *g)

   787 {

   788 	return call_forms_Ri (fl_get_choice, g-> ob_generic);

   789 }

   790 

   791 static PyObject *

   792 clear_choice (genericobject *g)

   793 {

   794 	return generic_call (g, fl_clear_choice);

   795 }

   796 

   797 static PyObject *

   798 addto_choice (genericobject *g, PyObject *args)

   799 {

   800 	return call_forms_INstr (fl_addto_choice, g-> ob_generic, args);

   801 }

   802 

   803 static PyObject *

   804 replace_choice (genericobject *g, PyObject *args)

   805 {

   806 	return call_forms_INiINstr (fl_replace_choice, g-> ob_generic, args);

   807 }

   808 

   809 static PyObject *

   810 delete_choice (genericobject *g, PyObject *args)

   811 {

   812 	return call_forms_INi (fl_delete_choice, g-> ob_generic, args);

   813 }

   814 

   815 static PyObject *

   816 get_choice_text (genericobject *g)

   817 {

   818 	return call_forms_Rstr (fl_get_choice_text, g-> ob_generic);

   819 }

   820 

   821 static PyObject *

   822 set_choice_fontsize (genericobject *g, PyObject *args)

   823 {

   824 	return call_forms_INf (fl_set_choice_fontsize, g-> ob_generic, args);

   825 }

   826 

   827 static PyObject *

   828 set_choice_fontstyle (genericobject *g, PyObject *args)

   829 {

   830 	return call_forms_INi (fl_set_choice_fontstyle, g-> ob_generic, args);

   831 }

   832 

   833 static PyMethodDef choice_methods[] = {

   834 	{"set_choice",		(PyCFunction)set_choice,      METH_OLDARGS},

   835 	{"get_choice",		(PyCFunction)get_choice,      METH_NOARGS},

   836 	{"clear_choice",	(PyCFunction)clear_choice,    METH_NOARGS},

   837 	{"addto_choice",	(PyCFunction)addto_choice,    METH_OLDARGS},

   838 	{"replace_choice",	(PyCFunction)replace_choice,  METH_OLDARGS},

   839 	{"delete_choice",	(PyCFunction)delete_choice,   METH_OLDARGS},

   840 	{"get_choice_text",	(PyCFunction)get_choice_text, METH_NOARGS},

   841 	{"set_choice_fontsize", (PyCFunction)set_choice_fontsize, METH_OLDARGS},

   842 	{"set_choice_fontstyle",(PyCFunction)set_choice_fontstyle, METH_OLDARGS},

   843 	{NULL,			NULL}		/* sentinel */

   844 };

   845 

   846 /* Class : Clock */

   847 

   848 static PyObject *

   849 get_clock(genericobject *g)

   850 {

   851 	int i0, i1, i2;

   852 

   853 	fl_get_clock (g->ob_generic, &i0, &i1, &i2);

   854 

   855 	return Py_BuildValue("(iii)", i0, i1, i2);

   856 }

   857 

   858 static PyMethodDef clock_methods[] = {

   859 	{"get_clock",		(PyCFunction)get_clock, METH_NOARGS},

   860 	{NULL,			NULL}		/* sentinel */

   861 };

   862 

   863 /* CLass : Counters */

   864 

   865 static PyObject *

   866 get_counter_value(genericobject *g)

   867 {

   868 	return call_forms_Rf (fl_get_counter_value, g-> ob_generic);

   869 }

   870 

   871 static PyObject *

   872 set_counter_value (genericobject *g, PyObject *args)

   873 {

   874 	return call_forms_INf (fl_set_counter_value, g-> ob_generic, args);

   875 }

   876 

   877 static PyObject *

   878 set_counter_precision (genericobject *g, PyObject *args)

   879 {

   880 	return call_forms_INi (fl_set_counter_precision, g-> ob_generic, args);

   881 }

   882 

   883 static PyObject *

   884 set_counter_bounds (genericobject *g, PyObject *args)

   885 {

   886 	return call_forms_INfINf (fl_set_counter_bounds, g-> ob_generic, args);

   887 }

   888 

   889 static PyObject *

   890 set_counter_step (genericobject *g, PyObject *args)

   891 {

   892 	return call_forms_INfINf (fl_set_counter_step, g-> ob_generic, args);

   893 }

   894 

   895 static PyObject *

   896 set_counter_return (genericobject *g, PyObject *args)

   897 {

   898 	return call_forms_INi (fl_set_counter_return, g-> ob_generic, args);

   899 }

   900 

   901 static PyMethodDef counter_methods[] = {

   902 	{"set_counter_value",		(PyCFunction)set_counter_value,

   903 	 METH_OLDARGS},

   904 	{"get_counter_value",		(PyCFunction)get_counter_value,

   905 	 METH_NOARGS},

   906 	{"set_counter_bounds",		(PyCFunction)set_counter_bounds,

   907 	 METH_OLDARGS},

   908 	{"set_counter_step",		(PyCFunction)set_counter_step,

   909 	 METH_OLDARGS},

   910 	{"set_counter_precision",	(PyCFunction)set_counter_precision,

   911 	 METH_OLDARGS},

   912 	{"set_counter_return",		(PyCFunction)set_counter_return,

   913 	 METH_OLDARGS},

   914 	{NULL,				NULL}		/* sentinel */

   915 };

   916 

   917 

   918 /* Class: Dials */

   919 

   920 static PyObject *

   921 get_dial_value(genericobject *g)

   922 {

   923 	return call_forms_Rf (fl_get_dial_value, g-> ob_generic);

   924 }

   925 

   926 static PyObject *

   927 set_dial_value (genericobject *g, PyObject *args)

   928 {

   929 	return call_forms_INf (fl_set_dial_value, g-> ob_generic, args);

   930 }

   931 

   932 static PyObject *

   933 set_dial_bounds (genericobject *g, PyObject *args)

   934 {

   935 	return call_forms_INfINf (fl_set_dial_bounds, g-> ob_generic, args);

   936 }

   937 

   938 static PyObject *

   939 get_dial_bounds (genericobject *g)

   940 {

   941 	return call_forms_OUTfOUTf (fl_get_dial_bounds, g-> ob_generic);

   942 }

   943 

   944 static PyObject *

   945 set_dial_step (genericobject *g, PyObject *args)

   946 {

   947 	return call_forms_INf (fl_set_dial_step, g-> ob_generic, args);

   948 }

   949 

   950 static PyMethodDef dial_methods[] = {

   951 	{"set_dial_value",	(PyCFunction)set_dial_value,  METH_OLDARGS},

   952 	{"get_dial_value",	(PyCFunction)get_dial_value,  METH_NOARGS},

   953 	{"set_dial_bounds",	(PyCFunction)set_dial_bounds, METH_OLDARGS},

   954 	{"get_dial_bounds",	(PyCFunction)get_dial_bounds, METH_NOARGS},

   955 	{"set_dial_step",	(PyCFunction)set_dial_step,   METH_OLDARGS},

   956 	{NULL,			NULL}		/* sentinel */

   957 };

   958 

   959 /* Class : Input */

   960 

   961 static PyObject *

   962 set_input (genericobject *g, PyObject *args)

   963 {

   964 	return call_forms_INstr (fl_set_input, g-> ob_generic, args);

   965 }

   966 

   967 static PyObject *

   968 get_input (genericobject *g)

   969 {

   970 	return call_forms_Rstr (fl_get_input, g-> ob_generic);

   971 }

   972 

   973 static PyObject *

   974 set_input_color (genericobject *g, PyObject *args)

   975 {

   976 	return call_forms_INfINf (fl_set_input_color, g-> ob_generic, args);

   977 }

   978 

   979 static PyObject *

   980 set_input_return (genericobject *g, PyObject *args)

   981 {

   982 	return call_forms_INi (fl_set_input_return, g-> ob_generic, args);

   983 }

   984 

   985 static PyMethodDef input_methods[] = {

   986 	{"set_input",		(PyCFunction)set_input,        METH_OLDARGS},

   987 	{"get_input",		(PyCFunction)get_input,        METH_NOARGS},

   988 	{"set_input_color",	(PyCFunction)set_input_color,  METH_OLDARGS},

   989 	{"set_input_return",	(PyCFunction)set_input_return, METH_OLDARGS},

   990 	{NULL,			NULL}		/* sentinel */

   991 };

   992 

   993 

   994 /* Class : Menu */

   995 

   996 static PyObject *

   997 set_menu (genericobject *g, PyObject *args)

   998 {

   999 	return call_forms_INstr (fl_set_menu, g-> ob_generic, args);

  1000 }

  1001 

  1002 static PyObject *

  1003 get_menu (genericobject *g)

  1004 {

  1005 	/* XXX strictly speaking this is wrong since fl_get_menu

  1006 	   XXX returns long, not int */

  1007 	return call_forms_Ri (fl_get_menu, g-> ob_generic);

  1008 }

  1009 

  1010 static PyObject *

  1011 get_menu_text (genericobject *g)

  1012 {

  1013 	return call_forms_Rstr (fl_get_menu_text, g-> ob_generic);

  1014 }

  1015 

  1016 static PyObject *

  1017 addto_menu (genericobject *g, PyObject *args)

  1018 {

  1019 	return call_forms_INstr (fl_addto_menu, g-> ob_generic, args);

  1020 }

  1021 

  1022 static PyMethodDef menu_methods[] = {

  1023 	{"set_menu",		(PyCFunction)set_menu,      METH_OLDARGS},

  1024 	{"get_menu",		(PyCFunction)get_menu,      METH_NOARGS},

  1025 	{"get_menu_text",	(PyCFunction)get_menu_text, METH_NOARGS},

  1026 	{"addto_menu",		(PyCFunction)addto_menu,    METH_OLDARGS},

  1027 	{NULL,			NULL}		/* sentinel */

  1028 };

  1029 

  1030 

  1031 /* Class: Sliders */

  1032 

  1033 static PyObject *

  1034 get_slider_value(genericobject *g)

  1035 {

  1036 	return call_forms_Rf (fl_get_slider_value, g-> ob_generic);

  1037 }

  1038 

  1039 static PyObject *

  1040 set_slider_value (genericobject *g, PyObject *args)

  1041 {

  1042 	return call_forms_INf (fl_set_slider_value, g-> ob_generic, args);

  1043 }

  1044 

  1045 static PyObject *

  1046 set_slider_bounds (genericobject *g, PyObject *args)

  1047 {

  1048 	return call_forms_INfINf (fl_set_slider_bounds, g-> ob_generic, args);

  1049 }

  1050 

  1051 static PyObject *

  1052 get_slider_bounds (genericobject *g)

  1053 {

  1054 	return call_forms_OUTfOUTf(fl_get_slider_bounds, g-> ob_generic);

  1055 }

  1056 

  1057 static PyObject *

  1058 set_slider_return (genericobject *g, PyObject *args)

  1059 {

  1060 	return call_forms_INf (fl_set_slider_return, g-> ob_generic, args);

  1061 }

  1062 

  1063 static PyObject *

  1064 set_slider_size (genericobject *g, PyObject *args)

  1065 {

  1066 	return call_forms_INf (fl_set_slider_size, g-> ob_generic, args);

  1067 }

  1068 

  1069 static PyObject *

  1070 set_slider_precision (genericobject *g, PyObject *args)

  1071 {

  1072 	return call_forms_INi (fl_set_slider_precision, g-> ob_generic, args);

  1073 }

  1074 

  1075 static PyObject *

  1076 set_slider_step (genericobject *g, PyObject *args)

  1077 {

  1078 	return call_forms_INf (fl_set_slider_step, g-> ob_generic, args);

  1079 }

  1080 

  1081 

  1082 static PyMethodDef slider_methods[] = {

  1083 	{"set_slider_value",	(PyCFunction)set_slider_value,  METH_OLDARGS},

  1084 	{"get_slider_value",	(PyCFunction)get_slider_value,  METH_NOARGS},

  1085 	{"set_slider_bounds",	(PyCFunction)set_slider_bounds, METH_OLDARGS},

  1086 	{"get_slider_bounds",	(PyCFunction)get_slider_bounds, METH_NOARGS},

  1087 	{"set_slider_return",	(PyCFunction)set_slider_return, METH_OLDARGS},

  1088 	{"set_slider_size",	(PyCFunction)set_slider_size,   METH_OLDARGS},

  1089 	{"set_slider_precision",(PyCFunction)set_slider_precision, METH_OLDARGS},

  1090 	{"set_slider_step",	(PyCFunction)set_slider_step,   METH_OLDARGS},

  1091 	{NULL,			NULL}		/* sentinel */

  1092 };

  1093 

  1094 static PyObject *

  1095 set_positioner_xvalue (genericobject *g, PyObject *args)

  1096 {

  1097 	return call_forms_INf (fl_set_positioner_xvalue, g-> ob_generic, args);

  1098 }

  1099 

  1100 static PyObject *

  1101 set_positioner_xbounds (genericobject *g, PyObject *args)

  1102 {

  1103 	return call_forms_INfINf (fl_set_positioner_xbounds,

  1104 				  g-> ob_generic, args);

  1105 }

  1106 

  1107 static PyObject *

  1108 set_positioner_yvalue (genericobject *g, PyObject *args)

  1109 {

  1110 	return call_forms_INf (fl_set_positioner_yvalue, g-> ob_generic, args);

  1111 }

  1112 

  1113 static PyObject *

  1114 set_positioner_ybounds (genericobject *g, PyObject *args)

  1115 {

  1116 	return call_forms_INfINf (fl_set_positioner_ybounds,

  1117 				  g-> ob_generic, args);

  1118 }

  1119 

  1120 static PyObject *

  1121 get_positioner_xvalue (genericobject *g)

  1122 {

  1123 	return call_forms_Rf (fl_get_positioner_xvalue, g-> ob_generic);

  1124 }

  1125 

  1126 static PyObject *

  1127 get_positioner_xbounds (genericobject *g)

  1128 {

  1129 	return call_forms_OUTfOUTf (fl_get_positioner_xbounds, g-> ob_generic);

  1130 }

  1131 

  1132 static PyObject *

  1133 get_positioner_yvalue (genericobject *g)

  1134 {

  1135 	return call_forms_Rf (fl_get_positioner_yvalue, g-> ob_generic);