#include "Python.h"

#include "forms.h"

#include "structmember.h"

typedef struct {

PyObject_HEAD

FL_OBJECT *ob_generic;

PyMethodDef *ob_methods;

PyObject *ob_callback;

PyObject *ob_callback_arg;

} genericobject;

static PyTypeObject GenericObjecttype;

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

static PyObject *allgenerics = NULL;

static int nfreeslots = 0;

static void

knowgeneric(genericobject *g)

{

int i, n;

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

if (allgenerics == NULL) {

allgenerics = PyList_New(0);

if (allgenerics == NULL) {

PyErr_Clear();

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

}

}

if (nfreeslots > 0) {

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

/* XXX This can be made faster! */

n = PyList_Size(allgenerics);

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

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

Py_INCREF(g);

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

nfreeslots--;

return;

}

}

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

nfreeslots = 0;

}

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

PyList_Append(allgenerics, (PyObject *)g);

}

static genericobject *

findgeneric(FL_OBJECT *generic)

{

int i, n;

genericobject *g;

if (allgenerics == NULL)

return NULL; /* No objects known yet */

n = PyList_Size(allgenerics);

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

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

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

return g;

}

return NULL; /* Unknown object */

}

static void

forgetgeneric(genericobject *g)

{

int i, n;

Py_CLEAR(g->ob_callback);

Py_CLEAR(g->ob_callback_arg);

if (allgenerics == NULL)

return; /* No objects known yet */

n = PyList_Size(allgenerics);

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

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

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

nfreeslots++;

break;

}

}

}

static void

releaseobjects(FL_FORM *form)

{

int i, n;

genericobject *g;

if (allgenerics == NULL)

return; /* No objects known yet */

n = PyList_Size(allgenerics);

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

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

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

fl_delete_object(g->ob_generic);

/* The object is now unreachable for

Py_CLEAR(g->ob_callback);

Py_CLEAR(g->ob_callback_arg);

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

nfreeslots++;

}

}

}

static PyObject *

generic_set_call_back(genericobject *g, PyObject *args)

{

if (PyTuple_GET_SIZE(args) == 0) {

Py_XDECREF(g->ob_callback);

Py_XDECREF(g->ob_callback_arg);

g->ob_callback = NULL;

g->ob_callback_arg = NULL;

}

else {

PyObject *a, *b;

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

return NULL;

Py_XDECREF(g->ob_callback);

Py_XDECREF(g->ob_callback_arg);

g->ob_callback = a;

Py_INCREF(g->ob_callback);

g->ob_callback_arg = b;

Py_INCREF(g->ob_callback_arg);

}

Py_INCREF(Py_None);

return Py_None;

}

static PyObject *

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

{

(*func)(g->ob_generic);

Py_INCREF(Py_None);

return Py_None;

}

static PyObject *

generic_delete_object(genericobject *g)

{

PyObject *res;

res = generic_call(g, fl_delete_object);

if (res != NULL)

forgetgeneric(g);

return res;

}

static PyObject *

generic_show_object(genericobject *g)

{

return generic_call(g, fl_show_object);

}

static PyObject *

generic_hide_object(genericobject *g)

{

return generic_call(g, fl_hide_object);

}

static PyObject *

generic_redraw_object(genericobject *g)

{

return generic_call(g, fl_redraw_object);

}

#ifdef OBSOLETE_FORMS_CALLS

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

static PyObject *

generic_freeze_object(genericobject *g)

{

return generic_call(g, fl_freeze_object);

}

static PyObject *

generic_unfreeze_object(genericobject *g)

{

return generic_call(g, fl_unfreeze_object);

}

#endif /* OBSOLETE_FORMS_CALLS */

static PyObject *

generic_activate_object(genericobject *g)

{

return generic_call(g, fl_activate_object);

}

static PyObject *

generic_deactivate_object(genericobject *g)

{

return generic_call(g, fl_deactivate_object);

}

static PyObject *

generic_set_object_shortcut(genericobject *g, PyObject *args)

{

char *str;

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

return NULL;

fl_set_object_shortcut(g->ob_generic, str);

Py_INCREF(Py_None);

return Py_None;

}

static PyMethodDef generic_methods[] = {

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

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

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

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

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

#ifdef OBSOLETE_FORMS_CALLS

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

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

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

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

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

{NULL, NULL} /* sentinel */

};

static void

generic_dealloc(genericobject *g)

{

fl_free_object(g->ob_generic);

Py_XDECREF(g->ob_callback);

Py_XDECREF(g->ob_callback_arg);

PyObject_Del(g);

}

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

static struct memberlist generic_memberlist[] = {

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

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

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

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

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

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

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

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

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

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

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

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

/* "label" is treated specially! */

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

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

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

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

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

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

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

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

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

{NULL} /* Sentinel */

};

#undef OFF

static PyObject *

generic_getattr(genericobject *g, char *name)

{

PyObject *meth;

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

if (g-> ob_methods) {

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

if (meth != NULL) return meth;

PyErr_Clear();

}

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

if (meth != NULL)

return meth;

PyErr_Clear();

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

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

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

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

}

static int

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

{

int ret;

if (v == NULL) {

PyErr_SetString(PyExc_TypeError,

"can't delete forms object attributes");

return -1;

}

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

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

if (!PyString_Check(v)) {

PyErr_SetString(PyExc_TypeError,

"label attr must be string");

return -1;

}

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

return 0;

}

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

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

if (ret == 0)

fl_redraw_object(g->ob_generic);

return ret;

}

static PyObject *

generic_repr(genericobject *g)

{

char buf[100];

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

g, g->ob_generic->objclass);

return PyString_FromString(buf);

}

static PyTypeObject GenericObjecttype = {

PyObject_HEAD_INIT(&PyType_Type)

0, /*ob_size*/

"fl.FORMS_object", /*tp_name*/

sizeof(genericobject), /*tp_size*/

0, /*tp_itemsize*/

/* methods */

(destructor)generic_dealloc, /*tp_dealloc*/

0, /*tp_print*/

(getattrfunc)generic_getattr, /*tp_getattr*/

(setattrfunc)generic_setattr, /*tp_setattr*/

0, /*tp_compare*/

(reprfunc)generic_repr, /*tp_repr*/

};

static PyObject *

newgenericobject(FL_OBJECT *generic, PyMethodDef *methods)

{

genericobject *g;

g = PyObject_New(genericobject, &GenericObjecttype);

if (g == NULL)

return NULL;

g-> ob_generic = generic;

g->ob_methods = methods;

g->ob_callback = NULL;

g->ob_callback_arg = NULL;

knowgeneric(g);

return (PyObject *)g;

}

static PyObject *

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

{

float parameter;

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

(*func) (obj, parameter);

Py_INCREF(Py_None);

return Py_None;

}

static PyObject *

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

{

float par1, par2;

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

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

Py_INCREF(Py_None);

return Py_None;

}

static PyObject *

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

{

int parameter;

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

(*func) (obj, parameter);

Py_INCREF(Py_None);

return Py_None;

}

static PyObject *

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

{

char *a;

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

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

Py_INCREF(Py_None);

return Py_None;

}

static PyObject *

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

{

char *a;

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

(*func) (obj, a);

Py_INCREF(Py_None);

return Py_None;

}

static PyObject *

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

{

char *b;

int a;

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

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

Py_INCREF(Py_None);

return Py_None;

}

#ifdef UNUSED

static PyObject *

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

{

int par1, par2;

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

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

Py_INCREF(Py_None);

return Py_None;

}

static PyObject *

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

{

int retval;

retval = (*func) (obj);

return PyInt_FromLong ((long) retval);

}

static PyObject *

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

{

char *str;

str = (*func) (obj);

if (str == NULL) {

Py_INCREF(Py_None);

return Py_None;

}

return PyString_FromString (str);

}

static PyObject *

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

{

float retval;

retval = (*func) (obj);

return PyFloat_FromDouble (retval);

}

static PyObject *

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

{

float f1, f2;

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

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

}

#ifdef UNUSED

static PyObject *

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

{

float f;

(*func) (obj, &f);

return PyFloat_FromDouble (f);

}

static PyObject *

set_browser_topline(genericobject *g, PyObject *args)

{

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

}

static PyObject *

clear_browser(genericobject *g)

{

return generic_call (g, fl_clear_browser);

}

static PyObject *

add_browser_line (genericobject *g, PyObject *args)

{

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

}

static PyObject *

addto_browser (genericobject *g, PyObject *args)

{

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

}

static PyObject *

insert_browser_line (genericobject *g, PyObject *args)

{

return call_forms_INiINstr (fl_insert_browser_line,

g-> ob_generic, args);

}

static PyObject *

delete_browser_line (genericobject *g, PyObject *args)

{

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

}

static PyObject *

replace_browser_line (genericobject *g, PyObject *args)

{

return call_forms_INiINstr (fl_replace_browser_line,

g-> ob_generic, args);

}

static PyObject *

get_browser_line(genericobject *g, PyObject *args)

{

int i;

char *str;

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

return NULL;

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

if (str == NULL) {

Py_INCREF(Py_None);

return Py_None;

}

return PyString_FromString (str);

}

static PyObject *

load_browser (genericobject *g, PyObject *args)

{

/* XXX strictly speaking this is wrong since fl_load_browser

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

}

static PyObject *

get_browser_maxline(genericobject *g)

{

return call_forms_Ri (fl_get_browser_maxline, g-> ob_generic);

}

static PyObject *

select_browser_line (genericobject *g, PyObject *args)

{

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

}

static PyObject *

deselect_browser_line (genericobject *g, PyObject *args)

{

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

}

static PyObject *

deselect_browser (genericobject *g)

{

return generic_call (g, fl_deselect_browser);

}

static PyObject *

isselected_browser_line (genericobject *g, PyObject *args)

{

int i, j;

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

return NULL;

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

return PyInt_FromLong (j);

}

static PyObject *

get_browser (genericobject *g)

{

return call_forms_Ri (fl_get_browser, g-> ob_generic);

}

static PyObject *

set_browser_fontsize (genericobject *g, PyObject *args)

{

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

}

static PyObject *

set_browser_fontstyle (genericobject *g, PyObject *args)

{

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

}

static PyObject *

set_browser_specialkey (genericobject *g, PyObject *args)

{

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

}

static PyMethodDef browser_methods[] = {

{"set_browser_topline", (PyCFunction)set_browser_topline,

METH_OLDARGS},

{"clear_browser", (PyCFunction)clear_browser,

METH_NOARGS},

{"add_browser_line", (PyCFunction)add_browser_line,

METH_OLDARGS},

{"addto_browser", (PyCFunction)addto_browser,

METH_OLDARGS},

{"insert_browser_line", (PyCFunction)insert_browser_line,

METH_OLDARGS},

{"delete_browser_line", (PyCFunction)delete_browser_line,

METH_OLDARGS},

{"replace_browser_line", (PyCFunction)replace_browser_line,

METH_OLDARGS},

{"get_browser_line", (PyCFunction)get_browser_line,

METH_OLDARGS},

{"load_browser", (PyCFunction)load_browser,

METH_OLDARGS},

{"get_browser_maxline", (PyCFunction)get_browser_maxline,

METH_NOARGS,}

{"select_browser_line", (PyCFunction)select_browser_line,

METH_OLDARGS},

{"deselect_browser_line", (PyCFunction)deselect_browser_line,

METH_OLDARGS},

{"deselect_browser", (PyCFunction)deselect_browser,

METH_NOARGS,}

{"isselected_browser_line", (PyCFunction)isselected_browser_line,

METH_OLDARGS},

{"get_browser", (PyCFunction)get_browser,

METH_NOARGS,}

{"set_browser_fontsize", (PyCFunction)set_browser_fontsize,

METH_OLDARGS},

{"set_browser_fontstyle", (PyCFunction)set_browser_fontstyle,

METH_OLDARGS},

{"set_browser_specialkey", (PyCFunction)set_browser_specialkey,

METH_OLDARGS},

{NULL, NULL} /* sentinel */

};

static PyObject *

set_button(genericobject *g, PyObject *args)

{

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

}

static PyObject *

get_button(genericobject *g)

{

return call_forms_Ri (fl_get_button, g-> ob_generic);

}

static PyObject *

get_button_numb(genericobject *g)

{

return call_forms_Ri (fl_get_button_numb, g-> ob_generic);

}

static PyObject *

set_button_shortcut(genericobject *g, PyObject *args)

{

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

}

static PyMethodDef button_methods[] = {

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

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

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

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

{NULL, NULL} /* sentinel */

};

static PyObject *

set_choice(genericobject *g, PyObject *args)

{

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

}

static PyObject *

get_choice(genericobject *g)

{

return call_forms_Ri (fl_get_choice, g-> ob_generic);

}

static PyObject *

clear_choice (genericobject *g)

{

return generic_call (g, fl_clear_choice);

}

static PyObject *

addto_choice (genericobject *g, PyObject *args)

{

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

}

static PyObject *

replace_choice (genericobject *g, PyObject *args)

{

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

}

static PyObject *

delete_choice (genericobject *g, PyObject *args)

{

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

}

static PyObject *

get_choice_text (genericobject *g)

{

return call_forms_Rstr (fl_get_choice_text, g-> ob_generic);

}

static PyObject *

set_choice_fontsize (genericobject *g, PyObject *args)

{

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

}

static PyObject *

set_choice_fontstyle (genericobject *g, PyObject *args)

{

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

}

static PyMethodDef choice_methods[] = {

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

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

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

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

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

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

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

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

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

{NULL, NULL} /* sentinel */

};

static PyObject *

get_clock(genericobject *g)

{

int i0, i1, i2;

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

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

}

static PyMethodDef clock_methods[] = {

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

{NULL, NULL} /* sentinel */

};

static PyObject *

get_counter_value(genericobject *g)

{

return call_forms_Rf (fl_get_counter_value, g-> ob_generic);

}

static PyObject *

set_counter_value (genericobject *g, PyObject *args)

{

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

}

static PyObject *

set_counter_precision (genericobject *g, PyObject *args)

{

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

}

static PyObject *

set_counter_bounds (genericobject *g, PyObject *args)

{

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

}

static PyObject *

set_counter_step (genericobject *g, PyObject *args)

{

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

}

static PyObject *

set_counter_return (genericobject *g, PyObject *args)

{

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

}

static PyMethodDef counter_methods[] = {

{"set_counter_value", (PyCFunction)set_counter_value,

METH_OLDARGS},

{"get_counter_value", (PyCFunction)get_counter_value,

METH_NOARGS},

{"set_counter_bounds", (PyCFunction)set_counter_bounds,

METH_OLDARGS},

{"set_counter_step", (PyCFunction)set_counter_step,

METH_OLDARGS},

{"set_counter_precision", (PyCFunction)set_counter_precision,

METH_OLDARGS},

{"set_counter_return", (PyCFunction)set_counter_return,

METH_OLDARGS},

{NULL, NULL} /* sentinel */

};

static PyObject *

get_dial_value(genericobject *g)

{

return call_forms_Rf (fl_get_dial_value, g-> ob_generic);

}

static PyObject *

set_dial_value (genericobject *g, PyObject *args)

{

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

}

static PyObject *

set_dial_bounds (genericobject *g, PyObject *args)

{

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

}

static PyObject *

get_dial_bounds (genericobject *g)

{

return call_forms_OUTfOUTf (fl_get_dial_bounds, g-> ob_generic);

}

static PyObject *

set_dial_step (genericobject *g, PyObject *args)

{

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

}

static PyMethodDef dial_methods[] = {

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

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

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

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

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

{NULL, NULL} /* sentinel */

};

static PyObject *

set_input (genericobject *g, PyObject *args)

{

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

}

static PyObject *

get_input (genericobject *g)

{

return call_forms_Rstr (fl_get_input, g-> ob_generic);

}

static PyObject *

set_input_color (genericobject *g, PyObject *args)

{

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

}

static PyObject *

set_input_return (genericobject *g, PyObject *args)

{

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

}

static PyMethodDef input_methods[] = {

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

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

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

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

{NULL, NULL} /* sentinel */

};

static PyObject *

set_menu (genericobject *g, PyObject *args)

{

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

}

static PyObject *

get_menu (genericobject *g)

{