--- /dev/null
+/**********************************************************
+Copyright 1991 by Stichting Mathematisch Centrum, Amsterdam, The
+Netherlands.
+
+ All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the names of Stichting Mathematisch
+Centrum or CWI not be used in advertising or publicity pertaining to
+distribution of the software without specific, written prior permission.
+
+STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
+THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
+FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+******************************************************************/
+
+/* FL module -- interface to Mark Overmars' FORMS Library. */
+
+#include "forms.h"
+
+#include "allobjects.h"
+#include "import.h"
+#include "modsupport.h"
+#include "structmember.h"
+
+/* #include "ceval.h" */
+extern object *call_object(object *, object *);
+
+/* Generic Forms Objects */
+
+typedef struct {
+ OB_HEAD
+ FL_OBJECT *ob_generic;
+ struct methodlist *ob_methods;
+ object *ob_callback;
+ object *ob_callback_arg;
+} genericobject;
+
+/* List of all objects (later this should be a hash table on address...) */
+
+static object *allgenerics = NULL;
+
+static void
+knowgeneric(g)
+ genericobject *g;
+{
+ if (allgenerics == NULL) {
+ allgenerics = newlistobject(0);
+ if (allgenerics == NULL) {
+ err_clear();
+ return; /* Botte pech */
+ }
+ }
+ addlistitem(allgenerics, (object *)g);
+}
+
+static genericobject *
+findgeneric(generic)
+ FL_OBJECT *generic;
+{
+ int i, n;
+ genericobject *g;
+
+ if (allgenerics == NULL)
+ return NULL; /* Botte pech */
+ n = getlistsize(allgenerics);
+ for (i = 0; i < n; i++) {
+ g = (genericobject *)getlistitem(allgenerics, i);
+ if (g->ob_generic == generic)
+ return g;
+ }
+ return NULL; /* Unknown object */
+}
+
+
+/* Methods of generic objects */
+
+static object *
+generic_set_call_back(g, args)
+ genericobject *g;
+ object *args;
+{
+ if (args == NULL) {
+ XDECREF(g->ob_callback);
+ XDECREF(g->ob_callback_arg);
+ g->ob_callback = NULL;
+ g->ob_callback_arg = NULL;
+ }
+ else {
+ if (!is_tupleobject(args) || gettuplesize(args) != 2) {
+ err_badarg();
+ return NULL;
+ }
+ XDECREF(g->ob_callback);
+ XDECREF(g->ob_callback_arg);
+ g->ob_callback = gettupleitem(args, 0);
+ INCREF(g->ob_callback);
+ g->ob_callback_arg = gettupleitem(args, 1);
+ INCREF(g->ob_callback_arg);
+ }
+ INCREF(None);
+ return None;
+}
+
+static object *
+generic_call(g, args, func)
+ genericobject *g;
+ object *args;
+ void (*func)(FL_OBJECT *);
+{
+ if (!getnoarg(args))
+ return NULL;
+ (*func)(g->ob_generic);
+ INCREF(None);
+ return None;
+}
+
+static object *
+generic_show_object(g, args)
+ genericobject *g;
+ object *args;
+{
+ return generic_call(g, args, fl_show_object);
+}
+
+static object *
+generic_hide_object(g, args)
+ genericobject *g;
+ object *args;
+{
+ return generic_call(g, args, fl_hide_object);
+}
+
+static object *
+generic_redraw_object(g, args)
+ genericobject *g;
+ object *args;
+{
+ return generic_call(g, args, fl_redraw_object);
+}
+
+static object *
+generic_freeze_object(g, args)
+ genericobject *g;
+ object *args;
+{
+ return generic_call(g, args, fl_freeze_object);
+}
+
+static object *
+generic_unfreeze_object(g, args)
+ genericobject *g;
+ object *args;
+{
+ return generic_call(g, args, fl_unfreeze_object);
+}
+
+static struct methodlist generic_methods[] = {
+ {"set_call_back", generic_set_call_back},
+ {"show_object", generic_show_object},
+ {"hide_object", generic_hide_object},
+ {"redraw_object", generic_redraw_object},
+ {"freeze_object", generic_freeze_object},
+ {"unfreeze_object", generic_unfreeze_object},
+#if 0
+ {"handle_object", generic_handle_object},
+ {"handle_object_direct",generic_handle_object_direct},
+#endif
+ {NULL, NULL} /* sentinel */
+};
+
+static void
+generic_dealloc(g)
+ genericobject *g;
+{
+ /* XXX can't destroy forms objects !!! */
+ 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},
+ {"frozen", T_INT, OFF(frozen), RO},
+ {"active", T_INT, OFF(active), RO},
+ {"input", T_INT, OFF(input), RO},
+ {"visible", T_INT, OFF(visible), RO},
+ {"radio", T_INT, OFF(radio), RO},
+ {"automatic", T_INT, OFF(automatic), RO},
+ {NULL} /* Sentinel */
+};
+
+static object *
+generic_getattr(g, name)
+ genericobject *g;
+ char *name;
+{
+ object *meth;
+
+ if (g-> ob_methods) {
+ meth = findmethod(g->ob_methods, (object *)g, name);
+ if (meth != NULL) return meth;
+ err_clear();
+ }
+
+ meth = findmethod(generic_methods, (object *)g, name);
+ if (meth != NULL)
+ return meth;
+ err_clear();
+
+ /* "label" is an exception, getmember only works for char pointers,
+ not for char arrays */
+ if (strcmp(name, "label") == 0)
+ return newstringobject(g->ob_generic->label);
+
+ return getmember((char *)g->ob_generic, generic_memberlist, name);
+}
+
+static int
+generic_setattr(g, name, v)
+ genericobject *g;
+ char *name;
+ object *v;
+{
+ int ret;
+
+ if (v == NULL) {
+ err_setstr(TypeError, "can't delete forms object attributes");
+ return NULL;
+ }
+
+ /* "label" is an exception: setmember doesn't set strings;
+ and FORMS wants you to call a function to set the label */
+ if (strcmp(name, "label") == 0) {
+ if (!is_stringobject(v)) {
+ err_setstr(TypeError, "label attr must be string");
+ return NULL;
+ }
+ fl_set_object_label(g->ob_generic, getstringvalue(v));
+ return 0;
+ }
+
+ ret = setmember((char *)g->ob_generic, generic_memberlist, name, v);
+
+ /* Rather than calling all the various set_object_* functions,
+ we call fl_redraw_object here. This is sometimes redundant
+ but I doubt that's a big problem */
+ if (ret == 0)
+ fl_redraw_object(g->ob_generic);
+
+ return ret;
+}
+
+typeobject GenericObjecttype = {
+ OB_HEAD_INIT(&Typetype)
+ 0, /*ob_size*/
+ "generic FORMS object", /*tp_name*/
+ sizeof(genericobject), /*tp_size*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ generic_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ generic_getattr, /*tp_getattr*/
+ generic_setattr, /*tp_setattr*/
+ 0, /*tp_compare*/
+ 0, /*tp_repr*/
+};
+
+static object *
+newgenericobject(generic, methods)
+ FL_OBJECT *generic;
+ struct methodlist *methods;
+{
+ genericobject *g;
+ g = NEWOBJ(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 (object *)g;
+}
+
+/**********************************************************************/
+/* Some common calling sequences */
+
+/* void func (object, float) */
+static object *
+call_forms_INf (func, obj, args)
+ void *(*func)(FL_OBJECT *, float);
+ FL_OBJECT *obj;
+ object *args;
+{
+ float parameter;
+
+ if (!getfloatarg (args, ¶meter)) return NULL;
+
+ (*func) (obj, parameter);
+
+ INCREF(None);
+ return None;
+}
+
+/* void func (object, float) */
+static object *
+call_forms_INfINf (func, obj, args)
+ void *(*func)(FL_OBJECT *, float, float);
+ FL_OBJECT *obj;
+ object *args;
+{
+ float par1, par2;
+
+ if (!getfloatfloatarg (args, &par1, &par2)) return NULL;
+
+ (*func) (obj, par1, par2);
+
+ INCREF(None);
+ return None;
+}
+
+/* void func (object, int) */
+static object *
+call_forms_INi (func, obj, args)
+ void *(*func)(FL_OBJECT *, int);
+ FL_OBJECT *obj;
+ object *args;
+{
+ int parameter;
+
+ if (!getintarg (args, ¶meter)) return NULL;
+
+ (*func) (obj, parameter);
+
+ INCREF(None);
+ return None;
+}
+
+/* void func (object, string) */
+static object *
+call_forms_INstr (func, obj, args)
+ void *(*func)(FL_OBJECT *, char *);
+ FL_OBJECT *obj;
+ object *args;
+{
+ object *a;
+
+ if (!getstrarg (args, &a)) return NULL;
+
+ (*func) (obj, getstringvalue (a));
+
+ INCREF(None);
+ return None;
+}
+
+
+/* voide func (object, int, string) */
+static object *
+call_forms_INiINstr (func, obj, args)
+ void *(*func)(FL_OBJECT *, int, char *);
+ FL_OBJECT *obj;
+ object *args;
+
+{
+ object *a;
+ int b;
+
+ if (!getintstrarg (args, &b, &a)) return NULL;
+
+ (*func) (obj, b, getstringvalue (a));
+
+ INCREF(None);
+ return None;
+}
+
+/* void func (object, float) */
+static object *
+call_forms_INiINi (func, obj, args)
+ void *(*func)(FL_OBJECT *, float, float);
+ FL_OBJECT *obj;
+ object *args;
+{
+ int par1, par2;
+
+ if (!getintintarg (args, &par1, &par2)) return NULL;
+
+ (*func) (obj, par1, par2);
+
+ INCREF(None);
+ return None;
+}
+
+/* int func (object) */
+static object *
+call_forms_Ri (func, obj, args)
+ int (*func)(FL_OBJECT *);
+ FL_OBJECT *obj;
+ object *args;
+{
+ int retval;
+
+ if (!getnoarg(args)) return NULL;
+
+ retval = (*func) (obj);
+
+ return newintobject ((long) retval);
+}
+
+/* char * func (object) */
+static object *
+call_forms_Rstr (func, obj, args)
+ char * (*func)(FL_OBJECT *);
+ FL_OBJECT *obj;
+ object *args;
+{
+ char *str;
+
+ if (!getnoarg (args)) return NULL;
+
+ str = (*func) (obj);
+
+ return newstringobject (str);
+}
+
+/* int func (object) */
+static object *
+call_forms_Rf (func, obj, args)
+ float (*func)(FL_OBJECT *);
+ FL_OBJECT *obj;
+ object *args;
+{
+ float retval;
+
+ if (!getnoarg(args)) return NULL;
+
+ retval = (*func) (obj);
+
+ return newfloatobject (retval);
+}
+
+static object *
+call_forms_OUTfOUTf (func, obj, args)
+ void *(*func)(FL_OBJECT *, float *, float *);
+ FL_OBJECT *obj;
+ object *args;
+{
+ float f1, f2;
+ object *arg;
+
+ if (!getnoarg(args)) return NULL;
+
+ (*func) (obj, &f1, &f2);
+
+ arg = newtupleobject (2);
+ if (arg == NULL) return NULL;
+
+ settupleitem (arg, 0, newfloatobject (f1));
+ settupleitem (arg, 1, newfloatobject (f2));
+ return arg;
+}
+
+static object *
+call_forms_OUTf (func, obj, args)
+ void *(*func)(FL_OBJECT *, float *);
+ FL_OBJECT *obj;
+ object *args;
+{
+ float f;
+ object *arg;
+
+ if (!getnoarg(args)) return NULL;
+
+ (*func) (obj, &f);
+
+ return newfloatobject (f);
+}
+
+/**********************************************************************/
+/* Class : browser */
+
+static object *
+set_browser_topline(g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_INi (fl_set_browser_topline, g-> ob_generic, args);
+}
+
+static object *
+clear_browser(g, args)
+ genericobject *g;
+ object *args;
+{
+ return generic_call (g, args, fl_clear_browser);
+}
+
+static object *
+add_browser_line (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_INstr (fl_add_browser_line, g-> ob_generic, args);
+}
+
+static object *
+addto_browser (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_INstr (fl_addto_browser, g-> ob_generic, args);
+}
+
+static object *
+insert_browser_line (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_INiINstr (fl_insert_browser_line, g-> ob_generic, args);
+}
+
+static object *
+delete_browser_line (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_INi (fl_delete_browser_line, g-> ob_generic, args);
+}
+
+static object *
+replace_browser_line (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_INiINstr (fl_replace_browser_line, g-> ob_generic, args);
+}
+
+static object *
+get_browser_line(g, args)
+ genericobject *g;
+ object *args;
+{
+ int i;
+ char *str;
+
+ if (!getintarg(args, &i))
+ return NULL;
+
+ str = fl_get_browser_line (g->ob_generic, i);
+
+ return newstringobject (str);
+}
+
+static object *
+load_browser (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_INstr (fl_load_browser, g-> ob_generic, args);
+}
+
+static object *
+get_browser_maxline(g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_Ri (fl_get_browser_maxline, g-> ob_generic, args);
+}
+
+static object *
+select_browser_line (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_INi (fl_select_browser_line, g-> ob_generic, args);
+}
+
+static object *
+deselect_browser_line (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_INi (fl_deselect_browser_line, g-> ob_generic, args);
+}
+
+static object *
+deselect_browser (g, args)
+ genericobject *g;
+ object *args;
+{
+ return generic_call (g, args, fl_deselect_browser);
+}
+
+static object *
+isselected_browser_line (g, args)
+ genericobject *g;
+ object *args;
+{
+ int i, j;
+ object *arg;
+
+ if (!getintarg(args, &i))
+ return NULL;
+
+ j = fl_isselected_browser_line (g->ob_generic, i);
+
+ return newintobject (j);
+}
+
+static object *
+get_browser (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_Ri (fl_get_browser, g-> ob_generic, args);
+}
+
+static object *
+set_browser_fontsize (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_INf (fl_set_browser_fontsize, g-> ob_generic, args);
+}
+
+static object *
+set_browser_fontstyle (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_INi (fl_set_browser_fontstyle, g-> ob_generic, args);
+}
+
+static struct methodlist browser_methods[] = {
+ {"set_browser_topline", set_browser_topline},
+ {"clear_browser", clear_browser},
+ {"add_browser_line", add_browser_line},
+ {"addto_browser", addto_browser},
+ {"insert_browser_line", insert_browser_line},
+ {"delete_browser_line", delete_browser_line},
+ {"replace_browser_line",replace_browser_line},
+ {"get_browser_line", get_browser_line},
+ {"load_browser", load_browser},
+ {"get_browser_maxline", get_browser_maxline},
+ {"select_browser_line", select_browser_line},
+ {"deselect_browser_line", deselect_browser_line},
+ {"deselect_browser", deselect_browser},
+ {"isselected_browser_line", isselected_browser_line},
+ {"get_browser", get_browser},
+ {"set_browser_fontsize",set_browser_fontsize},
+ {"set_browser_fontstyle", set_browser_fontstyle},
+ {NULL, NULL} /* sentinel */
+};
+
+/* Class: button */
+
+static object *
+set_button(g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_INi (fl_set_button, g-> ob_generic, args);
+}
+
+static object *
+get_button(g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_Ri (fl_get_button, g-> ob_generic, args);
+}
+
+static struct methodlist button_methods[] = {
+ {"set_button", set_button},
+ {"get_button", get_button},
+ {NULL, NULL} /* sentinel */
+};
+
+/* Class: choice */
+
+static object *
+set_choice(g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_INi (fl_set_choice, g-> ob_generic, args);
+}
+
+static object *
+get_choice(g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_Ri (fl_get_choice, g-> ob_generic, args);
+}
+
+static object *
+clear_choice (g, args)
+ genericobject *g;
+ object *args;
+{
+ generic_call (g, args, fl_clear_choice);
+}
+
+static object *
+addto_choice (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_INstr (fl_addto_choice, g-> ob_generic, args);
+}
+
+static object *
+replace_choice (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_INiINstr (fl_replace_choice, g-> ob_generic, args);
+}
+
+static object *
+delete_choice (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_INi (fl_delete_choice, g-> ob_generic, args);
+}
+
+static object *
+get_choice_text (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_Rstr (fl_get_choice_text, g-> ob_generic, args);
+}
+
+static object *
+set_choice_fontsize (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_INf (fl_set_choice_fontsize, g-> ob_generic, args);
+}
+
+static object *
+set_choice_fontstyle (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_INi (fl_set_choice_fontstyle, g-> ob_generic, args);
+}
+
+static struct methodlist choice_methods[] = {
+ {"set_choice", set_choice},
+ {"get_choice", get_choice},
+ {"clear_choice", clear_choice},
+ {"addto_choice", addto_choice},
+ {"replace_choice", replace_choice},
+ {"delete_choice", delete_choice},
+ {"get_choice_text", get_choice_text},
+ {"set_choice_fontsize", set_choice_fontsize},
+ {"set_choice_fontstyle",set_choice_fontstyle},
+ {NULL, NULL} /* sentinel */
+};
+
+/* Class : Clock */
+
+static object *
+get_clock(g, args)
+ genericobject *g;
+ object *args;
+{
+ int i0, i1, i2;
+ object *arg;
+
+ if (!getnoarg(args))
+ return NULL;
+
+ fl_get_clock (g->ob_generic, &i0, &i1, &i2);
+
+ arg = newtupleobject (3);
+ if (arg == NULL) return NULL;
+
+ settupleitem (arg, 0, newintobject (i0));
+ settupleitem (arg, 1, newintobject (i1));
+ settupleitem (arg, 2, newintobject (i2));
+ return arg;
+}
+
+static struct methodlist clock_methods[] = {
+ {"get_clock", get_clock},
+ {NULL, NULL} /* sentinel */
+};
+
+/* CLass : Counters */
+
+static object *
+get_counter_value(g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_Rf (fl_get_counter_value, g-> ob_generic, args);
+}
+
+static object *
+set_counter_value (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_INf (fl_set_counter_value, g-> ob_generic, args);
+}
+
+static object *
+set_counter_precision (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_INi (fl_set_counter_precision, g-> ob_generic, args);
+}
+
+static object *
+set_counter_bounds (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_INfINf (fl_set_counter_bounds, g-> ob_generic, args);
+}
+
+static object *
+set_counter_step (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_INfINf (fl_set_counter_step, g-> ob_generic, args);
+}
+
+static object *
+set_counter_return (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_INi (fl_set_counter_return, g-> ob_generic, args);
+}
+
+static struct methodlist counter_methods[] = {
+ {"set_counter_value", set_counter_value},
+ {"get_counter_value", get_counter_value},
+ {"set_counter_bounds", set_counter_bounds},
+ {"set_counter_step", set_counter_step},
+ {"set_counter_precision", set_counter_precision},
+ {"set_counter_return", set_counter_return},
+ {NULL, NULL} /* sentinel */
+};
+
+/* Class : Defaults */
+
+static object *
+get_default(g, args)
+ genericobject *g;
+ object *args;
+{
+ char c;
+
+ if (!getnoarg(args)) return NULL;
+
+ c = fl_get_default (g->ob_generic);
+
+ return ((object *) mknewcharobject (c)); /* in cgensupport.c */
+}
+
+static struct methodlist default_methods[] = {
+ {"get_default", get_default},
+ {NULL, NULL} /* sentinel */
+};
+
+
+/* Class: Dials */
+
+static object *
+set_dial (g, args)
+ genericobject *g;
+ object *args;
+{
+ float f1, f2, f3;
+
+ if (!getfloatfloatfloatarg(args, &f1, &f2, &f3))
+ return NULL;
+ fl_set_dial (g->ob_generic, f1, f2, f3);
+ INCREF(None);
+ return None;
+}
+
+static object *
+get_dial(g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_Rf (fl_get_dial, g-> ob_generic, args);
+}
+
+static object *
+set_dial_value (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_INf (fl_set_dial_value, g-> ob_generic, args);
+}
+
+static object *
+set_dial_bounds (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_INfINf (fl_set_dial_bounds, g-> ob_generic, args);
+}
+
+static object *
+get_dial_bounds (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_OUTfOUTf (fl_get_dial_bounds, g-> ob_generic, args);
+}
+
+static struct methodlist dial_methods[] = {
+ {"set_dial", set_dial},
+ {"get_dial", get_dial},
+ {"set_dial_value", set_dial_value},
+ {"get_dial_value", get_dial},
+ {"set_dial_bounds", set_dial_bounds},
+ {"get_dial_bounds", get_dial_bounds},
+ {NULL, NULL} /* sentinel */
+};
+
+/* Class : Input */
+
+static object *
+set_input (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_INstr (fl_set_input, g-> ob_generic, args);
+}
+
+static object *
+get_input (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_Rstr (fl_get_input, g-> ob_generic, args);
+}
+
+static object *
+set_input_color (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_INfINf (fl_set_input_color, g-> ob_generic, args);
+}
+
+static struct methodlist input_methods[] = {
+ {"set_input", set_input},
+ {"get_input", get_input},
+ {"set_input_color", set_input_color},
+ {NULL, NULL} /* sentinel */
+};
+
+
+/* Class : Menu */
+
+static object *
+set_menu (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_INstr (fl_set_menu, g-> ob_generic, args);
+}
+
+static object *
+get_menu (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_Ri (fl_get_menu, g-> ob_generic, args);
+}
+
+static object *
+addto_menu (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_INstr (fl_addto_menu, g-> ob_generic, args);
+}
+
+static struct methodlist menu_methods[] = {
+ {"set_menu", set_menu},
+ {"get_menu", get_menu},
+ {"addto_menu", addto_menu},
+ {NULL, NULL} /* sentinel */
+};
+
+
+/* Class: Sliders */
+
+static object *
+set_slider (g, args)
+ genericobject *g;
+ object *args;
+{
+ float f1, f2, f3;
+
+ if (!getfloatfloatfloatarg(args, &f1, &f2, &f3))
+ return NULL;
+ fl_set_slider (g->ob_generic, f1, f2, f3);
+ INCREF(None);
+ return None;
+}
+
+static object *
+get_slider(g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_Rf (fl_get_slider, g-> ob_generic, args);
+}
+
+static object *
+set_slider_value (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_INf (fl_set_slider_value, g-> ob_generic, args);
+}
+
+static object *
+set_slider_bounds (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_INfINf (fl_set_slider_bounds, g-> ob_generic, args);
+}
+
+static object *
+get_slider_bounds (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_OUTfOUTf(fl_get_slider_bounds, g-> ob_generic, args);
+}
+
+static object *
+set_slider_return (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_INf (fl_set_slider_return, g-> ob_generic, args);
+}
+
+static object *
+set_slider_size (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_INf (fl_set_slider_size, g-> ob_generic, args);
+}
+
+static object *
+set_slider_precision (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_INi (fl_set_slider_precision, g-> ob_generic, args);
+}
+
+static struct methodlist slider_methods[] = {
+ {"set_slider", set_slider},
+ {"get_slider", get_slider},
+ {"set_slider_value", set_slider_value},
+ {"get_slider_value", get_slider},
+ {"set_slider_bounds", set_slider_bounds},
+ {"get_slider_bounds", get_slider_bounds},
+ {"set_slider_return", set_slider_return},
+ {"set_slider_size", set_slider_size},
+ {"set_slider_precision",set_slider_precision},
+ {NULL, NULL} /* sentinel */
+};
+
+static object *
+set_positioner_xvalue (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_INf (fl_set_positioner_xvalue, g-> ob_generic, args);
+}
+
+static object *
+set_positioner_xbounds (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_INfINf (fl_set_positioner_xbounds, g-> ob_generic, args);
+}
+
+static object *
+set_positioner_yvalue (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_INf (fl_set_positioner_yvalue, g-> ob_generic, args);
+}
+
+static object *
+set_positioner_ybounds (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_INfINf (fl_set_positioner_ybounds, g-> ob_generic, args);
+}
+
+static object *
+get_positioner_xvalue (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_Rf (fl_get_positioner_xvalue, g-> ob_generic, args);
+}
+
+static object *
+get_positioner_xbounds (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_OUTfOUTf (fl_get_positioner_xbounds, g-> ob_generic, args);
+}
+
+static object *
+get_positioner_yvalue (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_Rf (fl_get_positioner_yvalue, g-> ob_generic, args);
+}
+
+static object *
+get_positioner_ybounds (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_OUTfOUTf (fl_get_positioner_ybounds, g-> ob_generic, args);
+}
+
+static struct methodlist positioner_methods[] = {
+ {"set_positioner_xvalue", set_positioner_xvalue},
+ {"set_positioner_yvalue", set_positioner_yvalue},
+ {"set_positioner_xbounds", set_positioner_xbounds},
+ {"set_positioner_ybounds", set_positioner_ybounds},
+ {"get_positioner_xvalue", get_positioner_xvalue},
+ {"get_positioner_yvalue", get_positioner_yvalue},
+ {"get_positioner_xbounds", get_positioner_xbounds},
+ {"get_positioner_ybounds", set_positioner_ybounds},
+ {NULL, NULL} /* sentinel */
+};
+
+/* Class timer */
+
+static object *
+set_timer (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_INf (fl_set_timer, g-> ob_generic, args);
+}
+
+static object *
+get_timer (g, args)
+ genericobject *g;
+ object *args;
+{
+ return call_forms_Rf (fl_get_timer, g-> ob_generic, args);
+}
+
+static struct methodlist timer_methods[] = {
+ {"set_timer", set_timer},
+ {"get_timer", get_timer},
+ {NULL, NULL} /* sentinel */
+};
+
+/* Form objects */
+
+typedef struct {
+ OB_HEAD
+ FL_FORM *ob_form;
+} formobject;
+
+extern typeobject Formtype; /* Forward */
+
+#define is_formobject(v) ((v)->ob_type == &Formtype)
+
+static object *
+form_show_form(f, args)
+ formobject *f;
+ object *args;
+{
+ int place, border;
+ object *name;
+ if (!getintintstrarg(args, &place, &border, &name))
+ return NULL;
+ fl_show_form(f->ob_form, place, border, getstringvalue(name));
+ INCREF(None);
+ return None;
+}
+
+static object *
+form_call(func, f, args)
+ FL_FORM *f;
+ object *args;
+ void (*func)(FL_FORM *);
+{
+ if (!getnoarg(args)) return NULL;
+
+ (*func)(f);
+
+ INCREF(None);
+ return None;
+}
+
+static object *
+form_call_INiINi (func, f, args)
+ FL_FORM *f;
+ object *args;
+ void (*func)(FL_FORM *, int, int);
+{
+ int a, b;
+
+ if (!getintintarg(args, &a, &b)) return NULL;
+
+ (*func)(f, a, b);
+
+ INCREF(None);
+ return None;
+}
+
+static object *
+form_hide_form(f, args)
+ formobject *f;
+ object *args;
+{
+ return form_call (fl_hide_form, f-> ob_form, args);
+}
+
+static object *
+form_redraw_form(f, args)
+ formobject *f;
+ object *args;
+{
+ return form_call (fl_redraw_form, f-> ob_form, args);
+}
+
+static object *
+form_set_form_position (f, args)
+ formobject *f;
+ object *args;
+{
+ return form_call_INiINi (fl_set_form_position, f-> ob_form, args);
+}
+
+static object *
+generic_add_object (f, args, func, internal_methods)
+ formobject *f;
+ object *args;
+ FL_OBJECT *(*func)(int, float, float, float, float, char*);
+ struct methodlist *internal_methods;
+{
+ int type;
+ float x, y, w, h;
+ object *name;
+ FL_OBJECT *genobj;
+
+ if (!getintfloatfloatfloatfloatstr (args,&type,&x,&y,&w,&h,&name))
+ return NULL;
+
+ fl_addto_form (f-> ob_form);
+
+ genobj = (*func) (type, x, y, w, h, getstringvalue (name));
+
+ fl_end_form ();
+
+ if (genobj == NULL) { err_nomem(); return NULL; }
+
+ return newgenericobject (genobj, internal_methods);
+}
+
+static object *
+form_add_button(f, args)
+ formobject *f;
+ object *args;
+{
+ return generic_add_object(f, args, fl_add_button, button_methods);
+}
+
+static object *
+form_add_lightbutton(f, args)
+ formobject *f;
+ object *args;
+{
+ return generic_add_object(f, args, fl_add_lightbutton, button_methods);
+}
+
+static object *
+form_add_roundbutton(f, args)
+ formobject *f;
+ object *args;
+{
+ return generic_add_object(f, args, fl_add_roundbutton, button_methods);
+}
+
+static object *
+form_add_menu (f, args)
+ formobject *f;
+ object *args;
+{
+ return generic_add_object(f, args, fl_add_menu, menu_methods);
+}
+
+static object *
+form_add_slider(f, args)
+ formobject *f;
+ object *args;
+{
+ return generic_add_object(f, args, fl_add_slider, slider_methods);
+}
+
+static object *
+form_add_valslider(f, args)
+ formobject *f;
+ object *args;
+{
+ return generic_add_object(f, args, fl_add_valslider, slider_methods);
+}
+
+static object *
+form_add_dial (f, args)
+ formobject *f;
+ object *args;
+{
+ return generic_add_object(f, args, fl_add_dial, dial_methods);
+}
+
+static object *
+form_add_counter (f, args)
+ formobject *f;
+ object *args;
+{
+ return generic_add_object(f, args, fl_add_counter, counter_methods);
+}
+
+static object *
+form_add_default (f, args)
+ formobject *f;
+ object *args;
+{
+ return generic_add_object(f, args, fl_add_default, default_methods);
+}
+
+static object *
+form_add_clock (f, args)
+ formobject *f;
+ object *args;
+{
+ return generic_add_object(f, args, fl_add_clock, clock_methods);
+}
+
+static object *
+form_add_box (f, args)
+ formobject *f;
+ object *args;
+{
+ return generic_add_object(f, args, fl_add_box, NULL);
+}
+
+static object *
+form_add_choice (f, args)
+ formobject *f;
+ object *args;
+{
+ return generic_add_object(f, args, fl_add_choice, choice_methods);
+}
+
+static object *
+form_add_browser (f, args)
+ formobject *f;
+ object *args;
+{
+ return generic_add_object(f, args, fl_add_browser, browser_methods);
+}
+
+static object *
+form_add_positioner (f, args)
+ formobject *f;
+ object *args;
+{
+ return generic_add_object(f, args, fl_add_positioner, positioner_methods);
+}
+
+static object *
+form_add_input (f, args)
+ formobject *f;
+ object *args;
+{
+ return generic_add_object(f, args, fl_add_input, input_methods);
+}
+
+static object *
+form_add_text (f, args)
+ formobject *f;
+ object *args;
+{
+ return generic_add_object(f, args, fl_add_text, NULL);
+}
+
+static object *
+form_add_timer (f, args)
+ formobject *f;
+ object *args;
+{
+ return generic_add_object(f, args, fl_add_timer, timer_methods);
+}
+
+static object *
+form_show_message (f, args)
+ formobject *f;
+ object *args;
+{
+ object *a, *b, *c;
+
+ if (!getstrstrstrarg(args, &a, &b, &c)) return NULL;
+
+ fl_show_message (
+ getstringvalue(a), getstringvalue(b), getstringvalue(c));
+
+ INCREF (None);
+ return None;
+}
+
+static object *
+form_show_question (f, args)
+ formobject *f;
+ object *args;
+{
+ int ret;
+ object *a, *b, *c;
+
+ if (!getstrstrstrarg(args, &a, &b, &c)) return NULL;
+
+ ret = fl_show_question (
+ getstringvalue(a), getstringvalue(b), getstringvalue(c));
+
+ return newintobject ((long) ret);
+}
+
+static object *
+form_show_input (f, args)
+ formobject *f;
+ object *args;
+{
+ char *str;
+ object *a, *b;
+
+ if (!getstrstrarg(args, &a, &b)) return NULL;
+
+ str = fl_show_input (getstringvalue(a), getstringvalue(b));
+
+ return newstringobject (str);
+}
+
+static object *
+form_file_selector (f, args)
+ formobject *f;
+ object *args;
+{
+ char *str;
+ object *a, *b, *c, *d;
+
+ if (!getstrstrstrstrarg(args, &a, &b, &c, &d)) return NULL;
+
+ str = fl_show_file_selector (getstringvalue(a), getstringvalue(b),
+ getstringvalue (c), getstringvalue (d));
+
+ return newstringobject (str);
+}
+
+
+static object *
+form_file_selector_func (f, args, func)
+ formobject *f;
+ object *args;
+ char *(*func)();
+{
+ char *str;
+
+ str = (*func) ();
+
+ return newstringobject (str);
+}
+
+static object *
+form_get_directory (f, args)
+ formobject *f;
+ object *args;
+{
+ return form_file_selector_func (f, args, fl_get_directory);
+}
+
+static object *
+form_get_pattern (f, args)
+ formobject *f;
+ object *args;
+{
+ return form_file_selector_func (f, args, fl_get_pattern);
+}
+
+static object *
+form_get_filename (f, args)
+ formobject *f;
+ object *args;
+{
+ return form_file_selector_func (f, args, fl_get_filename);
+
+}
+
+static object *
+form_freeze_form(f, args)
+ formobject *f;
+ object *args;
+{
+ return form_call (fl_freeze_form, f-> ob_form, args);
+}
+
+static object *
+form_unfreeze_form(f, args)
+ formobject *f;
+ object *args;
+{
+ return form_call (fl_unfreeze_form, f-> ob_form, args);
+}
+
+static object *
+form_display_form(f, args)
+ formobject *f;
+ object *args;
+{
+ int place, border;
+ object *name;
+ if (!getintintstrarg(args, &place, &border, &name))
+ return NULL;
+ fl_show_form(f->ob_form, place, border, getstringvalue(name));
+ INCREF(None);
+ return None;
+}
+
+static object *
+form_remove_form(f, args)
+ formobject *f;
+ object *args;
+{
+ return form_call (fl_remove_form, f-> ob_form, args);
+}
+
+static object *
+form_activate_form(f, args)
+ formobject *f;
+ object *args;
+{
+ return form_call (fl_activate_form, f-> ob_form, args);
+}
+
+static object *
+form_deactivate_form(f, args)
+ formobject *f;
+ object *args;
+{
+ return form_call (fl_deactivate_form, f-> ob_form, args);
+}
+
+static struct methodlist form_methods[] = {
+/* adm */
+ {"show_form", form_show_form},
+ {"hide_form", form_hide_form},
+ {"redraw_form", form_redraw_form},
+ {"set_form_position", form_set_form_position},
+ {"freeze_form", form_freeze_form},
+ {"unfreeze_form", form_unfreeze_form},
+ {"display_form", form_display_form},
+ {"remove_form", form_remove_form},
+ {"activate_form", form_activate_form},
+ {"deactivate_form", form_deactivate_form},
+
+/* basic objects */
+ {"add_button", form_add_button},
+/* {"add_bitmap", form_add_bitmap}, */
+ {"add_lightbutton", form_add_lightbutton},
+ {"add_roundbutton", form_add_roundbutton},
+ {"add_menu", form_add_menu},
+ {"add_slider", form_add_slider},
+ {"add_positioner", form_add_positioner},
+ {"add_valslider", form_add_valslider},
+ {"add_dial", form_add_dial},
+ {"add_counter", form_add_counter},
+ {"add_default", form_add_default},
+ {"add_box", form_add_box},
+ {"add_clock", form_add_clock},
+ {"add_choice", form_add_choice},
+ {"add_browser", form_add_browser},
+ {"add_input", form_add_input},
+ {"add_timer", form_add_timer},
+ {"add_text", form_add_text},
+ {NULL, NULL} /* sentinel */
+};
+
+static void
+form_dealloc(f)
+ formobject *f;
+{
+ /* XXX can't destroy form objects !!! */
+ DEL(f);
+}
+
+static object *
+form_getattr(f, name)
+ formobject *f;
+ char *name;
+{
+ /* XXX check for data attr's: x, y etc. */
+ return findmethod(form_methods, (object *)f, name);
+}
+
+typeobject Formtype = {
+ OB_HEAD_INIT(&Typetype)
+ 0, /*ob_size*/
+ "form", /*tp_name*/
+ sizeof(formobject), /*tp_size*/
+ 0, /*tp_itemsize*/
+ /* methods */
+ form_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ form_getattr, /*tp_getattr*/
+ 0, /*tp_setattr*/
+ 0, /*tp_compare*/
+ 0, /*tp_repr*/
+};
+
+static object *
+newformobject(form)
+ FL_FORM *form;
+{
+ formobject *f;
+ f = NEWOBJ(formobject, &Formtype);
+ if (f == NULL)
+ return NULL;
+ f->ob_form = form;
+ return (object *)f;
+}
+
+/* The "fl" module */
+static object *
+forms_make_form(dummy, args)
+ object *dummy;
+ object *args;
+{
+ int type;
+ float w, h;
+ FL_FORM *form;
+ if (!getintfloatfloatarg(args, &type, &w, &h))
+ return NULL;
+ form = fl_bgn_form(type, w, h);
+ if (form == NULL) {
+ /* XXX Actually, cannot happen! */
+ err_nomem();
+ return NULL;
+ }
+ fl_end_form();
+ return newformobject(form);
+}
+
+static object *my_event_callback = NULL;
+
+static object *
+forms_set_event_call_back(dummy, args)
+ object *dummy;
+ object *args;
+{
+ my_event_callback = args;
+ XINCREF(args);
+ INCREF(None);
+ return None;
+}
+
+static object *
+forms_do_or_check_forms(dummy, args, func)
+ object *dummy;
+ object *args;
+ FL_OBJECT *(*func)();
+{
+ FL_OBJECT *generic;
+ genericobject *g;
+ object *arg, *res;
+
+ if (!getnoarg(args))
+ return NULL;
+
+ for (;;) {
+ generic = (*func)();
+ if (generic == NULL) {
+ INCREF(None);
+ return None;
+ }
+ if (generic == FL_EVENT) {
+ int dev;
+ short val;
+ if (my_event_callback == NULL)
+ return newintobject(-1);
+ dev = fl_qread(&val);
+ arg = newtupleobject(2);
+ if (arg == NULL)
+ return NULL;
+ settupleitem(arg, 0, newintobject((long)dev));
+ settupleitem(arg, 1, newintobject((long)val));
+ res = call_object(my_event_callback, arg);
+ XDECREF(res);
+ DECREF(arg);
+ if (res == NULL)
+ return NULL; /* Callback raised exception */
+ continue;
+ }
+ g = findgeneric(generic);
+ if (g == NULL) {
+ err_setstr(RuntimeError,
+ "do_forms returns unknown object");
+ return NULL;
+ }
+ if (g->ob_callback == NULL) {
+ INCREF(g);
+ return ((object *) g);
+ }
+ arg = newtupleobject(2);
+ INCREF(g);
+ settupleitem(arg, 0, g);
+ INCREF(g->ob_callback_arg);
+ settupleitem(arg, 1, g->ob_callback_arg);
+ res = call_object(g->ob_callback, arg);
+ XDECREF(res);
+ DECREF(arg);
+ if (res == NULL)
+ return NULL; /* Callback raised exception */
+ }
+}
+
+static object *
+forms_do_forms (dummy, args)
+ object *dummy;
+ object *args;
+{
+ return forms_do_or_check_forms (dummy, args, fl_do_forms);
+}
+
+static object *
+forms_check_forms (dummy, args)
+ object *dummy;
+ object *args;
+{
+ return forms_do_or_check_forms (dummy, args, fl_check_forms);
+}
+
+static object *
+fl_call(func, args)
+ object *args;
+ void (*func)();
+{
+ if (!getnoarg(args))
+ return NULL;
+ (*func)();
+ INCREF(None);
+ return None;
+}
+
+static object *
+forms_bgn_group (dummy, args)
+ object *dummy;
+ object *args;
+{
+ return fl_call (fl_bgn_group, dummy, args);
+}
+
+static object *
+forms_end_group (dummy, args)
+ object *dummy;
+ object *args;
+{
+ return fl_call (fl_end_group, args);
+}
+
+static object *
+forms_qdevice(self, args)
+ object *self;
+ object *args;
+{
+ short arg1 ;
+ if (!getishortarg(args, 1, 0, &arg1))
+ return NULL;
+ fl_qdevice( arg1 );
+ INCREF(None);
+ return None;
+}
+
+static object *
+forms_unqdevice(self, args)
+ object *self;
+ object *args;
+{
+ short arg1 ;
+ if (!getishortarg(args, 1, 0, &arg1))
+ return NULL;
+ fl_unqdevice( arg1 );
+ INCREF(None);
+ return None;
+}
+
+static object *
+forms_isqueued(self, args)
+ object *self;
+ object *args;
+{
+ int retval;
+ short arg1 ;
+ if (!getishortarg(args, 1, 0, &arg1))
+ return NULL;
+ retval = fl_isqueued( arg1 );
+
+ return newintobject((int) retval);
+}
+
+static object *
+forms_qtest(self, args)
+ object *self;
+ object *args;
+{
+ long retval;
+ retval = fl_qtest( );
+ return newintobject((int) retval);
+}
+
+
+static object *
+forms_qread(self, args)
+ object *self;
+ object *args;
+{
+ long retval;
+ short arg1 ;
+ retval = fl_qread( & arg1 );
+ { object *v = newtupleobject( 2 );
+ if (v == NULL) return NULL;
+ settupleitem(v, 0, newintobject(retval));
+ settupleitem(v, 1, newintobject((long)arg1));
+ return v;
+ }
+}
+
+static object *
+forms_qreset(self, args)
+ object *self;
+ object *args;
+{
+ if (!getnoarg(args)) return NULL;
+
+ forms_qreset();
+ INCREF(None);
+ return None;
+}
+
+static object *
+forms_qenter(self, args)
+ object *self;
+ object *args;
+{
+ short arg1 ;
+ short arg2 ;
+ if (!getishortarg(args, 2, 0, &arg1))
+ return NULL;
+ if (!getishortarg(args, 2, 1, &arg2))
+ return NULL;
+ fl_qenter( arg1 , arg2 );
+ INCREF(None);
+ return None;
+}
+
+static object *
+forms_color (self, args)
+ object *self;
+ object *args;
+{
+ int arg;
+
+ if (!getintarg(args, &arg)) return NULL;
+
+ fl_color((short) arg);
+
+ INCREF(None);
+ return None;
+}
+
+static object *
+forms_mapcolor (self, args)
+ object *self;
+ object *args;
+{
+ int arg0, arg1, arg2, arg3;
+
+ if (!getintintintintarg(args, &arg0, &arg1, &arg2, &arg3))
+ return NULL;
+
+ fl_mapcolor(arg0, (short) arg1, (short) arg2, (short) arg3);
+
+ INCREF(None);
+ return None;
+}
+
+static object *
+forms_getmcolor (self, args)
+ object *self;
+ object *args;
+{
+ int arg, r, g, b;
+ object *v;
+
+ if (!getintarg(args, &arg)) return NULL;
+
+ fl_getmcolor (arg, (short) r, (short)g, (short)b);
+
+ v = newtupleobject(3);
+
+ if (v == NULL) return NULL;
+
+ settupleitem(v, 0, newintobject(r));
+ settupleitem(v, 1, newintobject(g));
+ settupleitem(v, 2, newintobject(b));
+
+ return v;
+}
+
+static object *
+forms_tie(self, args)
+ object *self;
+ object *args;
+{
+ short arg1 ;
+ short arg2 ;
+ short arg3 ;
+ if (!getishortarg(args, 3, 0, &arg1))
+ return NULL;
+ if (!getishortarg(args, 3, 1, &arg2))
+ return NULL;
+ if (!getishortarg(args, 3, 2, &arg3))
+ return NULL;
+ fl_tie( arg1 , arg2 , arg3 );
+ INCREF(None);
+ return None;
+}
+
+static struct methodlist forms_methods[] = {
+/* adm */
+ {"make_form", forms_make_form},
+ {"bgn_group", forms_bgn_group},
+ {"end_group", forms_end_group},
+/* gl support wrappers */
+ {"qdevice", forms_qdevice},
+ {"unqdevice", forms_unqdevice},
+ {"isqueued", forms_isqueued},
+ {"qtest", forms_qtest},
+ {"qread", forms_qread},
+/* {"blkqread", forms_blkqread}, */
+ {"qreset", forms_qreset},
+ {"qenter", forms_qenter},
+ {"tie", forms_tie},
+/* {"new_events", forms_new_events}, */
+ {"color", forms_color},
+ {"mapcolor", forms_mapcolor},
+ {"getmcolor", forms_getmcolor},
+/* interaction */
+ {"do_forms", forms_do_forms},
+ {"check_forms", forms_check_forms},
+ {"set_event_call_back", forms_set_event_call_back},
+/* goodies */
+ {"show_message", form_show_message},
+ {"show_question", form_show_question},
+ {"file_selector", form_file_selector},
+ {"get_directory", form_get_directory},
+ {"get_pattern", form_get_pattern},
+ {"get_filename", form_get_filename},
+/*
+ {"show_choice", form_show_choice},
+ XXX - draw.c
+*/
+ {"show_input", form_show_input},
+ {NULL, NULL} /* sentinel */
+};
+
+void
+initfl()
+{
+ initmodule("fl", forms_methods);
+ foreground ();
+}
+
+
+/* Support routines */
+
+int
+getintintstrarg(args, a, b, c)
+ object *args;
+ int *a, *b;
+ object **c;
+{
+ if (args == NULL || !is_tupleobject(args) || gettuplesize(args) != 3) {
+ err_badarg();
+ return NULL;
+ }
+ return getintarg(gettupleitem(args, 0), a) &&
+ getintarg(gettupleitem(args, 1), b) &&
+ getstrarg(gettupleitem(args, 2), c);
+}
+
+int
+getintfloatfloatarg(args, a, b, c)
+ object *args;
+ int *a;
+ float *b, *c;
+{
+ if (args == NULL || !is_tupleobject(args) || gettuplesize(args) != 3) {
+ err_badarg();
+ return NULL;
+ }
+ return getintarg(gettupleitem(args, 0), a) &&
+ getfloatarg(gettupleitem(args, 1), b) &&
+ getfloatarg(gettupleitem(args, 2), c);
+}
+
+int
+getintintintintarg(args, a, b, c, d)
+ object *args;
+ int *a, *b, *c, *d;
+{
+ if (args == NULL || !is_tupleobject(args) || gettuplesize(args) != 4) {
+ err_badarg();
+ return NULL;
+ }
+ return getintarg(gettupleitem(args, 0), a) &&
+ getintarg(gettupleitem(args, 1), b) &&
+ getintarg(gettupleitem(args, 2), c) &&
+ getintarg(gettupleitem(args, 3), d);
+}
+
+int
+getfloatarg(args, a)
+ object *args;
+ float *a;
+{
+ double x;
+ if (!getdoublearg(args, &x))
+ return 0;
+ *a = x;
+ return 1;
+}
+
+int
+getintfloatfloatfloatfloatstr (args, type, x, y, w, h, name)
+ object *args;
+ int *type;
+ float *x, *y, *w, *h;
+ object **name;
+{
+ if (args == NULL || !is_tupleobject(args) || gettuplesize(args) != 6) {
+ err_badarg();
+ return NULL;
+ }
+ return getintarg(gettupleitem(args, 0), type) &&
+ getfloatarg(gettupleitem(args, 1), x) &&
+ getfloatarg(gettupleitem(args, 2), y) &&
+ getfloatarg(gettupleitem(args, 3), w) &&
+ getfloatarg(gettupleitem(args, 4), h) &&
+ getstrarg(gettupleitem(args, 5), name);
+}
+
+int
+getfloatfloatfloatarg(args, f1, f2, f3)
+ object *args;
+ float *f1, *f2, *f3;
+{
+ if (args == NULL || !is_tupleobject(args) || gettuplesize(args) != 3) {
+ err_badarg();
+ return NULL;
+ }
+ return getfloatarg(gettupleitem(args, 0), f1) &&
+ getfloatarg(gettupleitem(args, 1), f2) &&
+ getfloatarg(gettupleitem(args, 2), f3);
+}
+
+int
+getfloatfloatarg(args, f1, f2)
+ object *args;
+ float *f1, *f2;
+{
+ if (args == NULL || !is_tupleobject(args) || gettuplesize(args) != 2) {
+ err_badarg();
+ return NULL;
+ }
+ return getfloatarg(gettupleitem(args, 0), f1) &&
+ getfloatarg(gettupleitem(args, 1), f2);
+}
+
+int
+getstrstrstrarg(v, a, b, c)
+ object *v;
+ object **a;
+ object **b;
+ object **c;
+{
+ if (v == NULL || !is_tupleobject(v) || gettuplesize(v) != 3) {
+ return err_badarg();
+ }
+ return getstrarg(gettupleitem(v, 0), a) &&
+ getstrarg(gettupleitem(v, 1), b)&&
+ getstrarg(gettupleitem(v, 2), c);
+}
+
+
+int
+getstrstrstrstrarg(v, a, b, c, d)
+ object *v;
+ object **a;
+ object **b;
+ object **c;
+ object **d;
+{
+ if (v == NULL || !is_tupleobject(v) || gettuplesize(v) != 4) {
+ return err_badarg();
+ }
+ return getstrarg(gettupleitem(v, 0), a) &&
+ getstrarg(gettupleitem(v, 1), b)&&
+ getstrarg(gettupleitem(v, 2), c) &&
+ getstrarg(gettupleitem(v, 3),d);
+
+}
projects / thirdparty / Python / cpython.git / commitdiff
