Modules/flmodule.c

   1 /**********************************************************
   2 Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
   3 The Netherlands.
   4
   5                         All Rights Reserved
   6
   7 Permission to use, copy, modify, and distribute this software and its
   8 documentation for any purpose and without fee is hereby granted,
   9 provided that the above copyright notice appear in all copies and that
  10 both that copyright notice and this permission notice appear in
  11 supporting documentation, and that the names of Stichting Mathematisch
  12 Centrum or CWI or Corporation for National Research Initiatives or
  13 CNRI not be used in advertising or publicity pertaining to
  14 distribution of the software without specific, written prior
  15 permission.
  16
  17 While CWI is the initial source for this software, a modified version
  18 is made available by the Corporation for National Research Initiatives
  19 (CNRI) at the Internet address ftp://ftp.python.org.
  20
  21 STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
  22 REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
  23 MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
  24 CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
  25 DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  26 PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  27 TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  28 PERFORMANCE OF THIS SOFTWARE.
  29
  30 ******************************************************************/
  31
  32 /* FL module -- interface to Mark Overmars' FORMS Library. */
  33
  34 /* This code works with FORMS version 2.2 (if you defined
  35    OBSOLETE_FORMS_CALLS), and 2.3.
  36    FORMS can be ftp'ed from ftp.cs.ruu.nl (131.211.80.17), directory
  37    /pub/SGI/FORMS. */
  38
  39 /* A half-hearted attempt has been made to allow programs using this
  40  * module to exploit parallelism (through the threads module). No provisions
  41  * have been made for multiple threads to use this module at the same time,
  42  * though. So, a program with a forms thread and a non-forms thread will work
  43  * fine but a program with two threads using forms will probably crash (unless
  44  * the program takes precaution to ensure that only one thread can be in
  45  * this module at any time). This will have to be fixed some time.
  46  * (A fix will probably also have to synchronise with the gl module).
  47  */
  48
  49 #include "Python.h"
  50 #include "forms.h"
  51 #include "structmember.h"
  52
  53 /* Generic Forms Objects */
  54
  55 typedef struct {
  56         PyObject_HEAD
  57         FL_OBJECT *ob_generic;
  58         PyMethodDef *ob_methods;
  59         PyObject *ob_callback;
  60         PyObject *ob_callback_arg;
  61 } genericobject;
  62
  63 staticforward PyTypeObject GenericObjecttype;
  64
  65 #define is_genericobject(g) ((g)->ob_type == &GenericObjecttype)
  66
  67 /* List of all objects (XXX this should be a hash table on address...) */
  68
  69 static PyObject *allgenerics = NULL;
  70 static int nfreeslots = 0;
  71
  72 /* Add an object to the list of known objects */
  73
  74 static void
  75 knowgeneric(g)
  76         genericobject *g;
  77 {
  78         int i, n;
  79         /* Create the list if it doesn't already exist */
  80         if (allgenerics == NULL) {
  81                 allgenerics = PyList_New(0);
  82                 if (allgenerics == NULL) {
  83                         PyErr_Clear();
  84                         return; /* Too bad, live without allgenerics... */
  85                 }
  86         }
  87         if (nfreeslots > 0) {
  88                 /* Search the list for reusable slots (NULL items) */
  89                 /* XXX This can be made faster! */
  90                 n = PyList_Size(allgenerics);
  91                 for (i = 0; i < n; i++) {
  92                         if (PyList_GetItem(allgenerics, i) == NULL) {
  93                                 Py_INCREF(g);
  94                                 PyList_SetItem(allgenerics, i, (PyObject *)g);
  95                                 nfreeslots--;
  96                                 return;
  97                         }
  98                 }
  99                 /* Strange... no free slots found... */
 100                 nfreeslots = 0;
 101         }
 102         /* No free entries, append new item to the end */
 103         PyList_Append(allgenerics, (PyObject *)g);
 104 }
 105
 106 /* Find an object in the list of known objects */
 107
 108 static genericobject *
 109 findgeneric(generic)
 110         FL_OBJECT *generic;
 111 {
 112         int i, n;
 113         genericobject *g;
 114
 115         if (allgenerics == NULL)
 116                 return NULL; /* No objects known yet */
 117         n = PyList_Size(allgenerics);
 118         for (i = 0; i < n; i++) {
 119                 g = (genericobject *)PyList_GetItem(allgenerics, i);
 120                 if (g != NULL && g->ob_generic == generic)
 121                         return g;
 122         }
 123         return NULL; /* Unknown object */
 124 }
 125
 126 /* Remove an object from the list of known objects */
 127
 128 static void
 129 forgetgeneric(g)
 130         genericobject *g;
 131 {
 132         int i, n;
 133
 134         Py_XDECREF(g->ob_callback);
 135         g->ob_callback = NULL;
 136         Py_XDECREF(g->ob_callback_arg);
 137         g->ob_callback_arg = NULL;
 138         if (allgenerics == NULL)
 139                 return; /* No objects known yet */
 140         n = PyList_Size(allgenerics);
 141         for (i = 0; i < n; i++) {
 142                 if (g == (genericobject *)PyList_GetItem(allgenerics, i)) {
 143                         PyList_SetItem(allgenerics, i, (PyObject *)NULL);
 144                         nfreeslots++;
 145                         break;
 146                 }
 147         }
 148 }
 149
 150 /* Called when a form is about to be freed --
 151    remove all the objects that we know about from it. */
 152
 153 static void
 154 releaseobjects(form)
 155         FL_FORM *form;
 156 {
 157         int i, n;
 158         genericobject *g;
 159
 160         if (allgenerics == NULL)
 161                 return; /* No objects known yet */
 162         n = PyList_Size(allgenerics);
 163         for (i = 0; i < n; i++) {
 164                 g = (genericobject *)PyList_GetItem(allgenerics, i);
 165                 if (g != NULL && g->ob_generic->form == form) {
 166                         fl_delete_object(g->ob_generic);
 167                         /* The object is now unreachable for
 168                            do_forms and check_forms, so
 169                            delete it from the list of known objects */
 170                         Py_XDECREF(g->ob_callback);
 171                         g->ob_callback = NULL;
 172                         Py_XDECREF(g->ob_callback_arg);
 173                         g->ob_callback_arg = NULL;
 174                         PyList_SetItem(allgenerics, i, (PyObject *)NULL);
 175                         nfreeslots++;
 176                 }
 177         }
 178 }
 179
 180
 181 /* Methods of generic objects */
 182
 183 static PyObject *
 184 generic_set_call_back(g, args)
 185         genericobject *g;
 186         PyObject *args;
 187 {
 188         if (args == NULL) {
 189                 Py_XDECREF(g->ob_callback);
 190                 Py_XDECREF(g->ob_callback_arg);
 191                 g->ob_callback = NULL;
 192                 g->ob_callback_arg = NULL;
 193         }
 194         else {
 195                 if (!PyTuple_Check(args) || PyTuple_Size(args) != 2) {
 196                         PyErr_BadArgument();
 197                         return NULL;
 198                 }
 199                 Py_XDECREF(g->ob_callback);
 200                 Py_XDECREF(g->ob_callback_arg);
 201                 g->ob_callback = PyTuple_GetItem(args, 0);
 202                 Py_INCREF(g->ob_callback);
 203                 g->ob_callback_arg = PyTuple_GetItem(args, 1);
 204                 Py_INCREF(g->ob_callback_arg);
 205         }
 206         Py_INCREF(Py_None);
 207         return Py_None;
 208 }
 209
 210 static PyObject *
 211 generic_call(g, args, func)
 212         genericobject *g;
 213         PyObject *args;
 214         void (*func)(FL_OBJECT *);
 215 {
 216         if (!PyArg_NoArgs(args))
 217                 return NULL;
 218         (*func)(g->ob_generic);
 219         Py_INCREF(Py_None);
 220         return Py_None;
 221 }
 222
 223 static PyObject *
 224 generic_delete_object(g, args)
 225         genericobject *g;
 226         PyObject *args;
 227 {
 228         PyObject *res;
 229         res = generic_call(g, args, fl_delete_object);
 230         if (res != NULL)
 231                 forgetgeneric(g);
 232         return res;
 233 }
 234
 235 static PyObject *
 236 generic_show_object(g, args)
 237         genericobject *g;
 238         PyObject *args;
 239 {
 240         return generic_call(g, args, fl_show_object);
 241 }
 242
 243 static PyObject *
 244 generic_hide_object(g, args)
 245         genericobject *g;
 246         PyObject *args;
 247 {
 248         return generic_call(g, args, fl_hide_object);
 249 }
 250
 251 static PyObject *
 252 generic_redraw_object(g, args)
 253         genericobject *g;
 254         PyObject *args;
 255 {
 256         return generic_call(g, args, fl_redraw_object);
 257 }
 258
 259 #ifdef OBSOLETE_FORMS_CALLS
 260
 261  /* (un)freeze_object() are obsolete in FORMS 2.2 and unsupported
 262     in 2.3.  Since there's no foolproof way to tell which version we're
 263     using, we omit them unconditionally. */
 264
 265 static PyObject *
 266 generic_freeze_object(g, args)
 267         genericobject *g;
 268         PyObject *args;
 269 {
 270         return generic_call(g, args, fl_freeze_object);
 271 }
 272
 273 static PyObject *
 274 generic_unfreeze_object(g, args)
 275         genericobject *g;
 276         PyObject *args;
 277 {
 278         return generic_call(g, args, fl_unfreeze_object);
 279 }
 280
 281 #endif /* OBSOLETE_FORMS_CALLS */
 282
 283 static PyObject *
 284 generic_activate_object(g, args)
 285         genericobject *g;
 286         PyObject *args;
 287 {
 288         return generic_call(g, args, fl_activate_object);
 289 }
 290
 291 static PyObject *
 292 generic_deactivate_object(g, args)
 293         genericobject *g;
 294         PyObject *args;
 295 {
 296         return generic_call(g, args, fl_deactivate_object);
 297 }
 298
 299 static PyObject *
 300 generic_set_object_shortcut(g, args)
 301         genericobject *g;
 302         PyObject *args;
 303 {
 304         char *str;
 305         if (!PyArg_Parse(args, "s", &str))
 306                 return NULL;
 307         fl_set_object_shortcut(g->ob_generic, str);
 308         Py_INCREF(Py_None);
 309         return Py_None;
 310 }
 311
 312 static PyMethodDef generic_methods[] = {
 313         {"set_call_back",       (PyCFunction)generic_set_call_back},
 314         {"delete_object",       (PyCFunction)generic_delete_object},
 315         {"show_object",         (PyCFunction)generic_show_object},
 316         {"hide_object",         (PyCFunction)generic_hide_object},
 317         {"redraw_object",       (PyCFunction)generic_redraw_object},
 318 #ifdef OBSOLETE_FORMS_CALLS
 319         {"freeze_object",       (PyCFunction)generic_freeze_object},
 320         {"unfreeze_object",     (PyCFunction)generic_unfreeze_object},
 321 #endif
 322         {"activate_object",     (PyCFunction)generic_activate_object},
 323         {"deactivate_object",   (PyCFunction)generic_deactivate_object},
 324         {"set_object_shortcut", (PyCFunction)generic_set_object_shortcut},
 325         {NULL,                  NULL}           /* sentinel */
 326 };
 327
 328 static void
 329 generic_dealloc(g)
 330         genericobject *g;
 331 {
 332         fl_free_object(g->ob_generic);
 333         Py_XDECREF(g->ob_callback);
 334         Py_XDECREF(g->ob_callback_arg);
 335         PyMem_DEL(g);
 336 }
 337
 338 #define OFF(x) offsetof(FL_OBJECT, x)
 339
 340 static struct memberlist generic_memberlist[] = {
 341         {"objclass",    T_INT,          OFF(objclass),  RO},
 342         {"type",        T_INT,          OFF(type),      RO},
 343         {"boxtype",     T_INT,          OFF(boxtype)},
 344         {"x",           T_FLOAT,        OFF(x)},
 345         {"y",           T_FLOAT,        OFF(y)},
 346         {"w",           T_FLOAT,        OFF(w)},
 347         {"h",           T_FLOAT,        OFF(h)},
 348         {"col1",        T_INT,          OFF(col1)},
 349         {"col2",        T_INT,          OFF(col2)},
 350         {"align",       T_INT,          OFF(align)},
 351         {"lcol",        T_INT,          OFF(lcol)},
 352         {"lsize",       T_FLOAT,        OFF(lsize)},
 353         /* "label" is treated specially! */
 354         {"lstyle",      T_INT,          OFF(lstyle)},
 355         {"pushed",      T_INT,          OFF(pushed),    RO},
 356         {"focus",       T_INT,          OFF(focus),     RO},
 357         {"belowmouse",  T_INT,          OFF(belowmouse),RO},
 358 /*      {"frozen",      T_INT,          OFF(frozen),    RO},    */
 359         {"active",      T_INT,          OFF(active)},
 360         {"input",       T_INT,          OFF(input)},
 361         {"visible",     T_INT,          OFF(visible),   RO},
 362         {"radio",       T_INT,          OFF(radio)},
 363         {"automatic",   T_INT,          OFF(automatic)},
 364         {NULL}  /* Sentinel */
 365 };
 366
 367 #undef OFF
 368
 369 static PyObject *
 370 generic_getattr(g, name)
 371         genericobject *g;
 372         char *name;
 373 {
 374         PyObject *meth;
 375
 376         /* XXX Ought to special-case name "__methods__" */
 377         if (g-> ob_methods) {
 378                 meth = Py_FindMethod(g->ob_methods, (PyObject *)g, name);
 379                 if (meth != NULL) return meth;
 380                 PyErr_Clear();
 381         }
 382
 383         meth = Py_FindMethod(generic_methods, (PyObject *)g, name);
 384         if (meth != NULL)
 385                 return meth;
 386         PyErr_Clear();
 387
 388         /* "label" is an exception, getmember only works for char pointers,
 389            not for char arrays */
 390         if (strcmp(name, "label") == 0)
 391                 return PyString_FromString(g->ob_generic->label);
 392
 393         return PyMember_Get((char *)g->ob_generic, generic_memberlist, name);
 394 }
 395
 396 static int
 397 generic_setattr(g, name, v)
 398         genericobject *g;
 399         char *name;
 400         PyObject *v;
 401 {
 402         int ret;
 403
 404         if (v == NULL) {
 405                 PyErr_SetString(PyExc_TypeError,
 406                                 "can't delete forms object attributes");
 407                 return -1;
 408         }
 409
 410         /* "label" is an exception: setmember doesn't set strings;
 411            and FORMS wants you to call a function to set the label */
 412         if (strcmp(name, "label") == 0) {
 413                 if (!PyString_Check(v)) {
 414                         PyErr_SetString(PyExc_TypeError,
 415                                         "label attr must be string");
 416                         return -1;
 417                 }
 418                 fl_set_object_label(g->ob_generic, PyString_AsString(v));
 419                 return 0;
 420         }
 421
 422         ret = PyMember_Set((char *)g->ob_generic, generic_memberlist, name, v);
 423
 424         /* Rather than calling all the various set_object_* functions,
 425            we call fl_redraw_object here.  This is sometimes redundant
 426            but I doubt that's a big problem */
 427         if (ret == 0)
 428                 fl_redraw_object(g->ob_generic);
 429
 430         return ret;
 431 }
 432
 433 static PyObject *
 434 generic_repr(g)
 435         genericobject *g;
 436 {
 437         char buf[100];
 438         sprintf(buf, "<FORMS_object at %lx, objclass=%d>",
 439                 (long)g, g->ob_generic->objclass);
 440         return PyString_FromString(buf);
 441 }
 442
 443 static PyTypeObject GenericObjecttype = {
 444         PyObject_HEAD_INIT(&PyType_Type)
 445         0,                              /*ob_size*/
 446         "FORMS_object",                 /*tp_name*/
 447         sizeof(genericobject),          /*tp_size*/
 448         0,                              /*tp_itemsize*/
 449         /* methods */
 450         (destructor)generic_dealloc,    /*tp_dealloc*/
 451         0,                              /*tp_print*/
 452         (getattrfunc)generic_getattr,   /*tp_getattr*/
 453         (setattrfunc)generic_setattr,   /*tp_setattr*/
 454         0,                              /*tp_compare*/
 455         (reprfunc)generic_repr,         /*tp_repr*/
 456 };
 457
 458 static PyObject *
 459 newgenericobject(generic, methods)
 460         FL_OBJECT *generic;
 461         PyMethodDef *methods;
 462 {
 463         genericobject *g;
 464         g = PyObject_NEW(genericobject, &GenericObjecttype);
 465         if (g == NULL)
 466                 return NULL;
 467         g-> ob_generic = generic;
 468         g->ob_methods = methods;
 469         g->ob_callback = NULL;
 470         g->ob_callback_arg = NULL;
 471         knowgeneric(g);
 472         return (PyObject *)g;
 473 }
 474
 475 /**********************************************************************/
 476 /* Some common calling sequences */
 477
 478 /* void func (object, float) */
 479 static PyObject *
 480 call_forms_INf (func, obj, args)
 481         void (*func)(FL_OBJECT *, float);
 482         FL_OBJECT *obj;
 483         PyObject *args;
 484 {
 485         float parameter;
 486
 487         if (!PyArg_Parse(args, "f", &parameter)) return NULL;
 488
 489         (*func) (obj, parameter);
 490
 491         Py_INCREF(Py_None);
 492         return Py_None;
 493 }
 494
 495 /* void func (object, float) */
 496 static PyObject *
 497 call_forms_INfINf (func, obj, args)
 498         void (*func)(FL_OBJECT *, float, float);
 499         FL_OBJECT *obj;
 500         PyObject *args;
 501 {
 502         float par1, par2;
 503
 504         if (!PyArg_Parse(args, "(ff)", &par1, &par2)) return NULL;
 505
 506         (*func) (obj, par1, par2);
 507
 508         Py_INCREF(Py_None);
 509         return Py_None;
 510 }
 511
 512 /* void func (object, int) */
 513 static PyObject *
 514 call_forms_INi (func, obj, args)
 515         void (*func)(FL_OBJECT *, int);
 516         FL_OBJECT *obj;
 517         PyObject *args;
 518 {
 519         int parameter;
 520
 521         if (!PyArg_Parse(args, "i", &parameter)) return NULL;
 522
 523         (*func) (obj, parameter);
 524
 525         Py_INCREF(Py_None);
 526         return Py_None;
 527 }
 528
 529 /* void func (object, char) */
 530 static PyObject *
 531 call_forms_INc (func, obj, args)
 532         void (*func)(FL_OBJECT *, int);
 533         FL_OBJECT *obj;
 534         PyObject *args;
 535 {
 536         char *a;
 537
 538         if (!PyArg_Parse(args, "s", &a)) return NULL;
 539
 540         (*func) (obj, a[0]);
 541
 542         Py_INCREF(Py_None);
 543         return Py_None;
 544 }
 545
 546 /* void func (object, string) */
 547 static PyObject *
 548 call_forms_INstr (func, obj, args)
 549         void (*func)(FL_OBJECT *, char *);
 550         FL_OBJECT *obj;
 551         PyObject *args;
 552 {
 553         char *a;
 554
 555         if (!PyArg_Parse(args, "s", &a)) return NULL;
 556
 557         (*func) (obj, a);
 558
 559         Py_INCREF(Py_None);
 560         return Py_None;
 561 }
 562
 563
 564 /* void func (object, int, string) */
 565 static PyObject *
 566 call_forms_INiINstr (func, obj, args)
 567         void (*func)(FL_OBJECT *, int, char *);
 568         FL_OBJECT *obj;
 569         PyObject *args;
 570 {
 571         char *b;
 572         int a;
 573
 574         if (!PyArg_Parse(args, "(is)", &a, &b)) return NULL;
 575
 576         (*func) (obj, a, b);
 577
 578         Py_INCREF(Py_None);
 579         return Py_None;
 580 }
 581
 582 #ifdef UNUSED
 583 /* void func (object, int, int) */
 584 static PyObject *
 585 call_forms_INiINi (func, obj, args)
 586         void (*func)(FL_OBJECT *, int, int);
 587         FL_OBJECT *obj;
 588         PyObject *args;
 589 {
 590         int par1, par2;
 591
 592         if (!PyArg_Parse(args, "(ii)", &par1, &par2)) return NULL;
 593
 594         (*func) (obj, par1, par2);
 595
 596         Py_INCREF(Py_None);
 597         return Py_None;
 598 }
 599 #endif
 600
 601 /* int func (object) */
 602 static PyObject *
 603 call_forms_Ri (func, obj, args)
 604         int (*func)(FL_OBJECT *);
 605         FL_OBJECT *obj;
 606         PyObject *args;
 607 {
 608         int retval;
 609
 610         if (!PyArg_NoArgs(args)) return NULL;
 611
 612         retval = (*func) (obj);
 613
 614         return PyInt_FromLong ((long) retval);
 615 }
 616
 617 /* char * func (object) */
 618 static PyObject *
 619 call_forms_Rstr (func, obj, args)
 620         char * (*func)(FL_OBJECT *);
 621         FL_OBJECT *obj;
 622         PyObject *args;
 623 {
 624         char *str;
 625
 626         if (!PyArg_NoArgs(args)) return NULL;
 627
 628         str = (*func) (obj);
 629
 630         if (str == NULL) {
 631                 Py_INCREF(Py_None);
 632                 return Py_None;
 633         }
 634         return PyString_FromString (str);
 635 }
 636
 637 /* int func (object) */
 638 static PyObject *
 639 call_forms_Rf (func, obj, args)
 640         float (*func)(FL_OBJECT *);
 641         FL_OBJECT *obj;
 642         PyObject *args;
 643 {
 644         float retval;
 645
 646         if (!PyArg_NoArgs(args)) return NULL;
 647
 648         retval = (*func) (obj);
 649
 650         return PyFloat_FromDouble (retval);
 651 }
 652
 653 static PyObject *
 654 call_forms_OUTfOUTf (func, obj, args)
 655         void (*func)(FL_OBJECT *, float *, float *);
 656         FL_OBJECT *obj;
 657         PyObject *args;
 658 {
 659         float f1, f2;
 660
 661         if (!PyArg_NoArgs(args)) return NULL;
 662
 663         (*func) (obj, &f1, &f2);
 664
 665         return Py_BuildValue("(ff)", f1, f2);
 666 }
 667
 668 #ifdef UNUSED
 669 static PyObject *
 670 call_forms_OUTf (func, obj, args)
 671         void (*func)(FL_OBJECT *, float *);
 672         FL_OBJECT *obj;
 673         PyObject *args;
 674 {
 675         float f;
 676
 677         if (!PyArg_NoArgs(args)) return NULL;
 678
 679         (*func) (obj, &f);
 680
 681         return PyFloat_FromDouble (f);
 682 }
 683 #endif
 684
 685 /**********************************************************************/
 686 /* Class : browser */
 687
 688 static PyObject *
 689 set_browser_topline(g, args)
 690         genericobject *g;
 691         PyObject *args;
 692 {
 693         return call_forms_INi (fl_set_browser_topline, g-> ob_generic, args);
 694 }
 695
 696 static PyObject *
 697 clear_browser(g, args)
 698         genericobject *g;
 699         PyObject *args;
 700 {
 701         return generic_call (g, args, fl_clear_browser);
 702 }
 703
 704 static PyObject *
 705 add_browser_line (g, args)
 706         genericobject *g;
 707         PyObject *args;
 708 {
 709         return call_forms_INstr (fl_add_browser_line, g-> ob_generic, args);
 710 }
 711
 712 static PyObject *
 713 addto_browser (g, args)
 714         genericobject *g;
 715         PyObject *args;
 716 {
 717         return call_forms_INstr (fl_addto_browser, g-> ob_generic, args);
 718 }
 719
 720 static PyObject *
 721 insert_browser_line (g, args)
 722         genericobject *g;
 723         PyObject *args;
 724 {
 725         return call_forms_INiINstr (fl_insert_browser_line,
 726                                     g-> ob_generic, args);
 727 }
 728
 729 static PyObject *
 730 delete_browser_line (g, args)
 731         genericobject *g;
 732         PyObject *args;
 733 {
 734         return call_forms_INi (fl_delete_browser_line, g-> ob_generic, args);
 735 }
 736
 737 static PyObject *
 738 replace_browser_line (g, args)
 739         genericobject *g;
 740         PyObject *args;
 741 {
 742         return call_forms_INiINstr (fl_replace_browser_line,
 743                                     g-> ob_generic, args);
 744 }
 745
 746 static PyObject *
 747 get_browser_line(g, args)
 748         genericobject *g;
 749         PyObject *args;
 750 {
 751         int i;
 752         char *str;
 753
 754         if (!PyArg_Parse(args, "i", &i))
 755                 return NULL;
 756
 757         str = fl_get_browser_line (g->ob_generic, i);
 758
 759         if (str == NULL) {
 760                 Py_INCREF(Py_None);
 761                 return Py_None;
 762         }
 763         return PyString_FromString (str);
 764 }
 765
 766 static PyObject *
 767 load_browser (g, args)
 768         genericobject *g;
 769         PyObject *args;
 770 {
 771         /* XXX strictly speaking this is wrong since fl_load_browser
 772            XXX returns int, not void */
 773         return call_forms_INstr (fl_load_browser, g-> ob_generic, args);
 774 }
 775
 776 static PyObject *
 777 get_browser_maxline(g, args)
 778         genericobject *g;
 779         PyObject *args;
 780 {
 781         return call_forms_Ri (fl_get_browser_maxline, g-> ob_generic, args);
 782 }
 783
 784 static PyObject *
 785 select_browser_line (g, args)
 786         genericobject *g;
 787         PyObject *args;
 788 {
 789         return call_forms_INi (fl_select_browser_line, g-> ob_generic, args);
 790 }
 791
 792 static PyObject *
 793 deselect_browser_line (g, args)
 794         genericobject *g;
 795         PyObject *args;
 796 {
 797         return call_forms_INi (fl_deselect_browser_line, g-> ob_generic, args);
 798 }
 799
 800 static PyObject *
 801 deselect_browser (g, args)
 802         genericobject *g;
 803         PyObject *args;
 804 {
 805         return generic_call (g, args, fl_deselect_browser);
 806 }
 807
 808 static PyObject *
 809 isselected_browser_line (g, args)
 810         genericobject *g;
 811         PyObject *args;
 812 {
 813         int i, j;
 814
 815         if (!PyArg_Parse(args, "i", &i))
 816                 return NULL;
 817
 818         j = fl_isselected_browser_line (g->ob_generic, i);
 819
 820         return PyInt_FromLong (j);
 821 }
 822
 823 static PyObject *
 824 get_browser (g, args)
 825         genericobject *g;
 826         PyObject *args;
 827 {
 828         return call_forms_Ri (fl_get_browser, g-> ob_generic, args);
 829 }
 830
 831 static PyObject *
 832 set_browser_fontsize (g, args)
 833         genericobject *g;
 834         PyObject *args;
 835 {
 836         return call_forms_INf (fl_set_browser_fontsize, g-> ob_generic, args);
 837 }
 838
 839 static PyObject *
 840 set_browser_fontstyle (g, args)
 841         genericobject *g;
 842         PyObject *args;
 843 {
 844         return call_forms_INi (fl_set_browser_fontstyle, g-> ob_generic, args);
 845 }
 846
 847 static PyObject *
 848 set_browser_specialkey (g, args)
 849         genericobject *g;
 850         PyObject *args;
 851 {
 852         return call_forms_INc(fl_set_browser_specialkey, g-> ob_generic, args);
 853 }
 854
 855 static PyMethodDef browser_methods[] = {
 856         {"set_browser_topline",         (PyCFunction)set_browser_topline},
 857         {"clear_browser",               (PyCFunction)clear_browser},
 858         {"add_browser_line",            (PyCFunction)add_browser_line},
 859         {"addto_browser",               (PyCFunction)addto_browser},
 860         {"insert_browser_line",         (PyCFunction)insert_browser_line},
 861         {"delete_browser_line",         (PyCFunction)delete_browser_line},
 862         {"replace_browser_line",        (PyCFunction)replace_browser_line},
 863         {"get_browser_line",            (PyCFunction)get_browser_line},
 864         {"load_browser",                (PyCFunction)load_browser},
 865         {"get_browser_maxline",         (PyCFunction)get_browser_maxline},
 866         {"select_browser_line",         (PyCFunction)select_browser_line},
 867         {"deselect_browser_line",       (PyCFunction)deselect_browser_line},
 868         {"deselect_browser",            (PyCFunction)deselect_browser},
 869         {"isselected_browser_line",     (PyCFunction)isselected_browser_line},
 870         {"get_browser",                 (PyCFunction)get_browser},
 871         {"set_browser_fontsize",        (PyCFunction)set_browser_fontsize},
 872         {"set_browser_fontstyle",       (PyCFunction)set_browser_fontstyle},
 873         {"set_browser_specialkey",      (PyCFunction)set_browser_specialkey},
 874         {NULL,                          NULL}           /* sentinel */
 875 };
 876
 877 /* Class: button */
 878
 879 static PyObject *
 880 set_button(g, args)
 881         genericobject *g;
 882         PyObject *args;
 883 {
 884         return call_forms_INi (fl_set_button, g-> ob_generic, args);
 885 }
 886
 887 static PyObject *
 888 get_button(g, args)
 889         genericobject *g;
 890         PyObject *args;
 891 {
 892         return call_forms_Ri (fl_get_button, g-> ob_generic, args);
 893 }
 894
 895 static PyObject *
 896 get_button_numb(g, args)
 897         genericobject *g;
 898         PyObject *args;
 899 {
 900         return call_forms_Ri (fl_get_button_numb, g-> ob_generic, args);
 901 }
 902
 903 static PyObject *
 904 set_button_shortcut(g, args)
 905         genericobject *g;
 906         PyObject *args;
 907 {
 908         return call_forms_INstr (fl_set_button_shortcut, g-> ob_generic, args);
 909 }
 910
 911 static PyMethodDef button_methods[] = {
 912         {"set_button",          (PyCFunction)set_button},
 913         {"get_button",          (PyCFunction)get_button},
 914         {"get_button_numb",     (PyCFunction)get_button_numb},
 915         {"set_button_shortcut", (PyCFunction)set_button_shortcut},
 916         {NULL,                  NULL}           /* sentinel */
 917 };
 918
 919 /* Class: choice */
 920
 921 static PyObject *
 922 set_choice(g, args)
 923         genericobject *g;
 924         PyObject *args;
 925 {
 926         return call_forms_INi (fl_set_choice, g-> ob_generic, args);
 927 }
 928
 929 static PyObject *
 930 get_choice(g, args)
 931         genericobject *g;
 932         PyObject *args;
 933 {
 934         return call_forms_Ri (fl_get_choice, g-> ob_generic, args);
 935 }
 936
 937 static PyObject *
 938 clear_choice (g, args)
 939         genericobject *g;
 940         PyObject *args;
 941 {
 942         return generic_call (g, args, fl_clear_choice);
 943 }
 944
 945 static PyObject *
 946 addto_choice (g, args)
 947         genericobject *g;
 948         PyObject *args;
 949 {
 950         return call_forms_INstr (fl_addto_choice, g-> ob_generic, args);
 951 }
 952
 953 static PyObject *
 954 replace_choice (g, args)
 955         genericobject *g;
 956         PyObject *args;
 957 {
 958         return call_forms_INiINstr (fl_replace_choice, g-> ob_generic, args);
 959 }
 960
 961 static PyObject *
 962 delete_choice (g, args)
 963         genericobject *g;
 964         PyObject *args;
 965 {
 966         return call_forms_INi (fl_delete_choice, g-> ob_generic, args);
 967 }
 968
 969 static PyObject *
 970 get_choice_text (g, args)
 971         genericobject *g;
 972         PyObject *args;
 973 {
 974         return call_forms_Rstr (fl_get_choice_text, g-> ob_generic, args);
 975 }
 976
 977 static PyObject *
 978 set_choice_fontsize (g, args)
 979         genericobject *g;
 980         PyObject *args;
 981 {
 982         return call_forms_INf (fl_set_choice_fontsize, g-> ob_generic, args);
 983 }
 984
 985 static PyObject *
 986 set_choice_fontstyle (g, args)
 987         genericobject *g;
 988         PyObject *args;
 989 {
 990         return call_forms_INi (fl_set_choice_fontstyle, g-> ob_generic, args);
 991 }
 992
 993 static PyMethodDef choice_methods[] = {
 994         {"set_choice",          (PyCFunction)set_choice},
 995         {"get_choice",          (PyCFunction)get_choice},
 996         {"clear_choice",        (PyCFunction)clear_choice},
 997         {"addto_choice",        (PyCFunction)addto_choice},
 998         {"replace_choice",      (PyCFunction)replace_choice},
 999         {"delete_choice",       (PyCFunction)delete_choice},
1000         {"get_choice_text",     (PyCFunction)get_choice_text},
1001         {"set_choice_fontsize", (PyCFunction)set_choice_fontsize},
1002         {"set_choice_fontstyle",(PyCFunction)set_choice_fontstyle},
1003         {NULL,                  NULL}           /* sentinel */
1004 };
1005
1006 /* Class : Clock */
1007
1008 static PyObject *
1009 get_clock(g, args)
1010         genericobject *g;
1011         PyObject *args;
1012 {
1013         int i0, i1, i2;
1014
1015         if (!PyArg_NoArgs(args))
1016                 return NULL;
1017
1018         fl_get_clock (g->ob_generic, &i0, &i1, &i2);
1019
1020         return Py_BuildValue("(iii)", i0, i1, i2);
1021 }
1022
1023 static PyMethodDef clock_methods[] = {
1024         {"get_clock",           (PyCFunction)get_clock},
1025         {NULL,                  NULL}           /* sentinel */
1026 };
1027
1028 /* CLass : Counters */
1029
1030 static PyObject *
1031 get_counter_value(g, args)
1032         genericobject *g;
1033         PyObject *args;
1034 {
1035         return call_forms_Rf (fl_get_counter_value, g-> ob_generic, args);
1036 }
1037
1038 static PyObject *
1039 set_counter_value (g, args)
1040         genericobject *g;
1041         PyObject *args;
1042 {
1043         return call_forms_INf (fl_set_counter_value, g-> ob_generic, args);
1044 }
1045
1046 static PyObject *
1047 set_counter_precision (g, args)
1048         genericobject *g;
1049         PyObject *args;
1050 {
1051         return call_forms_INi (fl_set_counter_precision, g-> ob_generic, args);
1052 }
1053
1054 static PyObject *
1055 set_counter_bounds (g, args)
1056         genericobject *g;
1057         PyObject *args;
1058 {
1059         return call_forms_INfINf (fl_set_counter_bounds, g-> ob_generic, args);
1060 }
1061
1062 static PyObject *
1063 set_counter_step (g, args)
1064         genericobject *g;
1065         PyObject *args;
1066 {
1067         return call_forms_INfINf (fl_set_counter_step, g-> ob_generic, args);
1068 }
1069
1070 static PyObject *
1071 set_counter_return (g, args)
1072         genericobject *g;
1073         PyObject *args;
1074 {
1075         return call_forms_INi (fl_set_counter_return, g-> ob_generic, args);
1076 }
1077
1078 static PyMethodDef counter_methods[] = {
1079         {"set_counter_value",           (PyCFunction)set_counter_value},
1080         {"get_counter_value",           (PyCFunction)get_counter_value},
1081         {"set_counter_bounds",          (PyCFunction)set_counter_bounds},
1082         {"set_counter_step",            (PyCFunction)set_counter_step},
1083         {"set_counter_precision",       (PyCFunction)set_counter_precision},
1084         {"set_counter_return",          (PyCFunction)set_counter_return},
1085         {NULL,                          NULL}           /* sentinel */
1086 };
1087
1088
1089 /* Class: Dials */
1090
1091 static PyObject *
1092 get_dial_value(g, args)
1093         genericobject *g;
1094         PyObject *args;
1095 {
1096         return call_forms_Rf (fl_get_dial_value, g-> ob_generic, args);
1097 }
1098
1099 static PyObject *
1100 set_dial_value (g, args)
1101         genericobject *g;
1102         PyObject *args;
1103 {
1104         return call_forms_INf (fl_set_dial_value, g-> ob_generic, args);
1105 }
1106
1107 static PyObject *
1108 set_dial_bounds (g, args)
1109         genericobject *g;
1110         PyObject *args;
1111 {
1112         return call_forms_INfINf (fl_set_dial_bounds, g-> ob_generic, args);
1113 }
1114
1115 static PyObject *
1116 get_dial_bounds (g, args)
1117         genericobject *g;
1118         PyObject *args;
1119 {
1120         return call_forms_OUTfOUTf (fl_get_dial_bounds, g-> ob_generic, args);
1121 }
1122
1123 static PyObject *
1124 set_dial_step (g, args)
1125         genericobject *g;
1126         PyObject *args;
1127 {
1128         return call_forms_INf (fl_set_dial_step, g-> ob_generic, args);
1129 }
1130
1131 static PyMethodDef dial_methods[] = {
1132         {"set_dial_value",      (PyCFunction)set_dial_value},
1133         {"get_dial_value",      (PyCFunction)get_dial_value},
1134         {"set_dial_bounds",     (PyCFunction)set_dial_bounds},
1135         {"get_dial_bounds",     (PyCFunction)get_dial_bounds},
1136         {"set_dial_step",       (PyCFunction)set_dial_step},
1137         {NULL,                  NULL}           /* sentinel */
1138 };
1139
1140 /* Class : Input */
1141
1142 static PyObject *
1143 set_input (g, args)
1144         genericobject *g;
1145         PyObject *args;
1146 {
1147         return call_forms_INstr (fl_set_input, g-> ob_generic, args);
1148 }
1149
1150 static PyObject *
1151 get_input (g, args)
1152         genericobject *g;
1153         PyObject *args;
1154 {
1155         return call_forms_Rstr (fl_get_input, g-> ob_generic, args);
1156 }
1157
1158 static PyObject *
1159 set_input_color (g, args)
1160         genericobject *g;
1161         PyObject *args;
1162 {
1163         return call_forms_INfINf (fl_set_input_color, g-> ob_generic, args);
1164 }
1165
1166 static PyObject *
1167 set_input_return (g, args)
1168         genericobject *g;
1169         PyObject *args;
1170 {
1171         return call_forms_INi (fl_set_input_return, g-> ob_generic, args);
1172 }
1173
1174 static PyMethodDef input_methods[] = {
1175         {"set_input",           (PyCFunction)set_input},
1176         {"get_input",           (PyCFunction)get_input},
1177         {"set_input_color",     (PyCFunction)set_input_color},
1178         {"set_input_return",    (PyCFunction)set_input_return},
1179         {NULL,                  NULL}           /* sentinel */
1180 };
1181
1182
1183 /* Class : Menu */
1184
1185 static PyObject *
1186 set_menu (g, args)
1187         genericobject *g;
1188         PyObject *args;
1189 {
1190         return call_forms_INstr (fl_set_menu, g-> ob_generic, args);
1191 }
1192
1193 static PyObject *
1194 get_menu (g, args)
1195         genericobject *g;
1196         PyObject *args;
1197 {
1198         /* XXX strictly speaking this is wrong since fl_get_menu
1199            XXX returns long, not int */
1200         return call_forms_Ri (fl_get_menu, g-> ob_generic, args);
1201 }
1202
1203 static PyObject *
1204 get_menu_text (g, args)
1205         genericobject *g;
1206         PyObject *args;
1207 {
1208         return call_forms_Rstr (fl_get_menu_text, g-> ob_generic, args);
1209 }
1210
1211 static PyObject *
1212 addto_menu (g, args)
1213         genericobject *g;
1214         PyObject *args;
1215 {
1216         return call_forms_INstr (fl_addto_menu, g-> ob_generic, args);
1217 }
1218
1219 static PyMethodDef menu_methods[] = {
1220         {"set_menu",            (PyCFunction)set_menu},
1221         {"get_menu",            (PyCFunction)get_menu},
1222         {"get_menu_text",       (PyCFunction)get_menu_text},
1223         {"addto_menu",          (PyCFunction)addto_menu},
1224         {NULL,                  NULL}           /* sentinel */
1225 };
1226
1227
1228 /* Class: Sliders */
1229
1230 static PyObject *
1231 get_slider_value(g, args)
1232         genericobject *g;
1233         PyObject *args;
1234 {
1235         return call_forms_Rf (fl_get_slider_value, g-> ob_generic, args);
1236 }
1237
1238 static PyObject *
1239 set_slider_value (g, args)
1240         genericobject *g;
1241         PyObject *args;
1242 {
1243         return call_forms_INf (fl_set_slider_value, g-> ob_generic, args);
1244 }
1245
1246 static PyObject *
1247 set_slider_bounds (g, args)
1248         genericobject *g;
1249         PyObject *args;
1250 {
1251         return call_forms_INfINf (fl_set_slider_bounds, g-> ob_generic, args);
1252 }
1253
1254 static PyObject *
1255 get_slider_bounds (g, args)
1256         genericobject *g;
1257         PyObject *args;
1258 {
1259         return call_forms_OUTfOUTf(fl_get_slider_bounds, g-> ob_generic, args);
1260 }
1261
1262 static PyObject *
1263 set_slider_return (g, args)
1264         genericobject *g;
1265         PyObject *args;
1266 {
1267         return call_forms_INf (fl_set_slider_return, g-> ob_generic, args);
1268 }
1269
1270 static PyObject *
1271 set_slider_size (g, args)
1272         genericobject *g;
1273         PyObject *args;
1274 {
1275         return call_forms_INf (fl_set_slider_size, g-> ob_generic, args);
1276 }
1277
1278 static PyObject *
1279 set_slider_precision (g, args)
1280         genericobject *g;
1281         PyObject *args;
1282 {
1283         return call_forms_INi (fl_set_slider_precision, g-> ob_generic, args);
1284 }
1285
1286 static PyObject *
1287 set_slider_step (g, args)
1288         genericobject *g;
1289         PyObject *args;
1290 {
1291         return call_forms_INf (fl_set_slider_step, g-> ob_generic, args);
1292 }
1293
1294
1295 static PyMethodDef slider_methods[] = {
1296         {"set_slider_value",    (PyCFunction)set_slider_value},
1297         {"get_slider_value",    (PyCFunction)get_slider_value},
1298         {"set_slider_bounds",   (PyCFunction)set_slider_bounds},
1299         {"get_slider_bounds",   (PyCFunction)get_slider_bounds},
1300         {"set_slider_return",   (PyCFunction)set_slider_return},
1301         {"set_slider_size",     (PyCFunction)set_slider_size},
1302         {"set_slider_precision",(PyCFunction)set_slider_precision},
1303         {"set_slider_step",     (PyCFunction)set_slider_step},
1304         {NULL,                  NULL}           /* sentinel */
1305 };
1306
1307 static PyObject *
1308 set_positioner_xvalue (g, args)
1309         genericobject *g;
1310         PyObject *args;
1311 {
1312         return call_forms_INf (fl_set_positioner_xvalue, g-> ob_generic, args);
1313 }
1314
1315 static PyObject *
1316 set_positioner_xbounds (g, args)
1317         genericobject *g;
1318         PyObject *args;
1319 {
1320         return call_forms_INfINf (fl_set_positioner_xbounds,
1321                                   g-> ob_generic, args);
1322 }
1323
1324 static PyObject *
1325 set_positioner_yvalue (g, args)
1326         genericobject *g;
1327         PyObject *args;
1328 {
1329         return call_forms_INf (fl_set_positioner_yvalue, g-> ob_generic, args);
1330 }
1331
1332 static PyObject *
1333 set_positioner_ybounds (g, args)
1334         genericobject *g;
1335         PyObject *args;
1336 {
1337         return call_forms_INfINf (fl_set_positioner_ybounds,
1338                                   g-> ob_generic, args);
1339 }
1340
1341 static PyObject *
1342 get_positioner_xvalue (g, args)
1343         genericobject *g;
1344         PyObject *args;
1345 {
1346         return call_forms_Rf (fl_get_positioner_xvalue, g-> ob_generic, args);
1347 }
1348
1349 static PyObject *
1350 get_positioner_xbounds (g, args)
1351         genericobject *g;
1352         PyObject *args;
1353 {
1354         return call_forms_OUTfOUTf (fl_get_positioner_xbounds,
1355                                     g-> ob_generic, args);
1356 }
1357
1358 static PyObject *
1359 get_positioner_yvalue (g, args)
1360         genericobject *g;
1361         PyObject *args;
1362 {
1363         return call_forms_Rf (fl_get_positioner_yvalue, g-> ob_generic, args);
1364 }
1365
1366 static PyObject *
1367 get_positioner_ybounds (g, args)
1368         genericobject *g;
1369         PyObject *args;
1370 {
1371         return call_forms_OUTfOUTf (fl_get_positioner_ybounds,
1372                                     g-> ob_generic, args);
1373 }
1374
1375 static PyMethodDef positioner_methods[] = {
1376         {"set_positioner_xvalue",       (PyCFunction)set_positioner_xvalue},
1377         {"set_positioner_yvalue",       (PyCFunction)set_positioner_yvalue},
1378         {"set_positioner_xbounds",      (PyCFunction)set_positioner_xbounds},
1379         {"set_positioner_ybounds",      (PyCFunction)set_positioner_ybounds},
1380         {"get_positioner_xvalue",       (PyCFunction)get_positioner_xvalue},
1381         {"get_positioner_yvalue",       (PyCFunction)get_positioner_yvalue},
1382         {"get_positioner_xbounds",      (PyCFunction)get_positioner_xbounds},
1383         {"get_positioner_ybounds",      (PyCFunction)get_positioner_ybounds},
1384         {NULL,                  NULL}           /* sentinel */
1385 };
1386
1387 /* Class timer */
1388
1389 static PyObject *
1390 set_timer (g, args)
1391         genericobject *g;
1392         PyObject *args;
1393 {
1394         return call_forms_INf (fl_set_timer, g-> ob_generic, args);
1395 }
1396
1397 static PyObject *
1398 get_timer (g, args)
1399         genericobject *g;
1400         PyObject *args;
1401 {
1402         return call_forms_Rf (fl_get_timer, g-> ob_generic, args);
1403 }
1404
1405 static PyMethodDef timer_methods[] = {
1406         {"set_timer",           (PyCFunction)set_timer},
1407         {"get_timer",           (PyCFunction)get_timer},
1408         {NULL,                  NULL}           /* sentinel */
1409 };
1410
1411 /* Form objects */
1412
1413 typedef struct {
1414         PyObject_HEAD
1415         FL_FORM *ob_form;
1416 } formobject;
1417
1418 staticforward PyTypeObject Formtype;
1419
1420 #define is_formobject(v) ((v)->ob_type == &Formtype)
1421
1422 static PyObject *
1423 form_show_form(f, args)
1424         formobject *f;
1425         PyObject *args;
1426 {
1427         int place, border;
1428         char *name;
1429         if (!PyArg_Parse(args, "(iis)", &place, &border, &name))
1430                 return NULL;
1431         fl_show_form(f->ob_form, place, border, name);
1432         Py_INCREF(Py_None);
1433         return Py_None;
1434 }
1435
1436 static PyObject *
1437 form_call(func, f, args)
1438         FL_FORM *f;
1439         PyObject *args;
1440         void (*func)(FL_FORM *);
1441 {
1442         if (!PyArg_NoArgs(args)) return NULL;
1443
1444         (*func)(f);
1445
1446         Py_INCREF(Py_None);
1447         return Py_None;
1448 }
1449
1450 static PyObject *
1451 form_call_INiINi(func, f, args)
1452         FL_FORM *f;
1453         PyObject *args;
1454         void (*func)(FL_FORM *, int, int);
1455 {
1456         int a, b;
1457
1458         if (!PyArg_Parse(args, "(ii)", &a, &b)) return NULL;
1459
1460         (*func)(f, a, b);
1461
1462         Py_INCREF(Py_None);
1463         return Py_None;
1464 }
1465
1466 static PyObject *
1467 form_call_INfINf(func, f, args)
1468         FL_FORM *f;
1469         PyObject *args;
1470         void (*func)(FL_FORM *, float, float);
1471 {
1472         float a, b;
1473
1474         if (!PyArg_Parse(args, "(ff)", &a, &b)) return NULL;
1475
1476         (*func)(f, a, b);
1477
1478         Py_INCREF(Py_None);
1479         return Py_None;
1480 }
1481
1482 static PyObject *
1483 form_hide_form(f, args)
1484         formobject *f;
1485         PyObject *args;
1486 {
1487         return form_call(fl_hide_form, f-> ob_form, args);
1488 }
1489
1490 static PyObject *
1491 form_redraw_form(f, args)
1492         formobject *f;
1493         PyObject *args;
1494 {
1495         return form_call(fl_redraw_form, f-> ob_form, args);
1496 }
1497
1498 static PyObject *
1499 form_set_form_position(f, args)
1500         formobject *f;
1501         PyObject *args;
1502 {
1503         return form_call_INiINi(fl_set_form_position, f-> ob_form, args);
1504 }
1505
1506 static PyObject *
1507 form_set_form_size(f, args)
1508         formobject *f;
1509         PyObject *args;
1510 {
1511         return form_call_INiINi(fl_set_form_size, f-> ob_form, args);
1512 }
1513
1514 static PyObject *
1515 form_scale_form(f, args)
1516         formobject *f;
1517         PyObject *args;
1518 {
1519         return form_call_INfINf(fl_scale_form, f-> ob_form, args);
1520 }
1521
1522 static PyObject *
1523 generic_add_object(f, args, func, internal_methods)
1524         formobject *f;
1525         PyObject *args;
1526         FL_OBJECT *(*func)(int, float, float, float, float, char*);
1527         PyMethodDef *internal_methods;
1528 {
1529         int type;
1530         float x, y, w, h;
1531         char *name;
1532         FL_OBJECT *obj;
1533
1534         if (!PyArg_Parse(args,"(iffffs)", &type,&x,&y,&w,&h,&name))
1535                 return NULL;
1536
1537         fl_addto_form (f-> ob_form);
1538
1539         obj = (*func) (type, x, y, w, h, name);
1540
1541         fl_end_form();
1542
1543         if (obj == NULL) {
1544                 PyErr_NoMemory();
1545                 return NULL;
1546         }
1547
1548         return newgenericobject (obj, internal_methods);
1549 }
1550
1551 static PyObject *
1552 form_add_button(f, args)
1553         formobject *f;
1554         PyObject *args;
1555 {
1556         return generic_add_object(f, args, fl_add_button, button_methods);
1557 }
1558
1559 static PyObject *
1560 form_add_lightbutton(f, args)
1561         formobject *f;
1562         PyObject *args;
1563 {
1564         return generic_add_object(f, args, fl_add_lightbutton, button_methods);
1565 }
1566
1567 static PyObject *
1568 form_add_roundbutton(f, args)
1569         formobject *f;
1570         PyObject *args;
1571 {
1572         return generic_add_object(f, args, fl_add_roundbutton, button_methods);
1573 }
1574
1575 static PyObject *
1576 form_add_menu (f, args)
1577         formobject *f;
1578         PyObject *args;
1579 {
1580         return generic_add_object(f, args, fl_add_menu, menu_methods);
1581 }
1582
1583 static PyObject *
1584 form_add_slider(f, args)
1585         formobject *f;
1586         PyObject *args;
1587 {
1588         return generic_add_object(f, args, fl_add_slider, slider_methods);
1589 }
1590
1591 static PyObject *
1592 form_add_valslider(f, args)
1593         formobject *f;
1594         PyObject *args;
1595 {
1596         return generic_add_object(f, args, fl_add_valslider, slider_methods);
1597 }
1598
1599 static PyObject *
1600 form_add_dial(f, args)
1601         formobject *f;
1602         PyObject *args;
1603 {
1604         return generic_add_object(f, args, fl_add_dial, dial_methods);
1605 }
1606
1607 static PyObject *
1608 form_add_counter(f, args)
1609         formobject *f;
1610         PyObject *args;
1611 {
1612         return generic_add_object(f, args, fl_add_counter, counter_methods);
1613 }
1614
1615 static PyObject *
1616 form_add_clock(f, args)
1617         formobject *f;
1618         PyObject *args;
1619 {
1620         return generic_add_object(f, args, fl_add_clock, clock_methods);
1621 }
1622
1623 static PyObject *
1624 form_add_box(f, args)
1625         formobject *f;
1626         PyObject *args;
1627 {
1628         return generic_add_object(f, args, fl_add_box,
1629                                   (PyMethodDef *)NULL);
1630 }
1631
1632 static PyObject *
1633 form_add_choice(f, args)
1634         formobject *f;
1635         PyObject *args;
1636 {
1637         return generic_add_object(f, args, fl_add_choice, choice_methods);
1638 }
1639
1640 static PyObject *
1641 form_add_browser(f, args)
1642         formobject *f;
1643         PyObject *args;
1644 {
1645         return generic_add_object(f, args, fl_add_browser, browser_methods);
1646 }
1647
1648 static PyObject *
1649 form_add_positioner(f, args)
1650         formobject *f;
1651         PyObject *args;
1652 {
1653         return generic_add_object(f, args, fl_add_positioner,
1654                                   positioner_methods);
1655 }
1656
1657 static PyObject *
1658 form_add_input(f, args)
1659         formobject *f;
1660         PyObject *args;
1661 {
1662         return generic_add_object(f, args, fl_add_input, input_methods);
1663 }
1664
1665 static PyObject *
1666 form_add_text(f, args)
1667         formobject *f;
1668         PyObject *args;
1669 {
1670         return generic_add_object(f, args, fl_add_text,
1671                                   (PyMethodDef *)NULL);
1672 }
1673
1674 static PyObject *
1675 form_add_timer(f, args)
1676         formobject *f;
1677         PyObject *args;
1678 {
1679         return generic_add_object(f, args, fl_add_timer, timer_methods);
1680 }
1681
1682 static PyObject *
1683 form_freeze_form(f, args)
1684         formobject *f;
1685         PyObject *args;
1686 {
1687         return form_call(fl_freeze_form, f-> ob_form, args);
1688 }
1689
1690 static PyObject *
1691 form_unfreeze_form(f, args)
1692         formobject *f;
1693         PyObject *args;
1694 {
1695         return form_call(fl_unfreeze_form, f-> ob_form, args);
1696 }
1697
1698 static PyObject *
1699 form_activate_form(f, args)
1700         formobject *f;
1701         PyObject *args;
1702 {
1703         return form_call(fl_activate_form, f-> ob_form, args);
1704 }
1705
1706 static PyObject *
1707 form_deactivate_form(f, args)
1708         formobject *f;
1709         PyObject *args;
1710 {
1711         return form_call(fl_deactivate_form, f-> ob_form, args);
1712 }
1713
1714 static PyObject *
1715 form_bgn_group(f, args)
1716         formobject *f;
1717         PyObject *args;
1718 {
1719         FL_OBJECT *obj;
1720
1721         fl_addto_form(f-> ob_form);
1722         obj = fl_bgn_group();
1723         fl_end_form();
1724
1725         if (obj == NULL) {
1726                 PyErr_NoMemory();
1727                 return NULL;
1728         }
1729
1730         return newgenericobject (obj, (PyMethodDef *) NULL);
1731 }
1732
1733 static PyObject *
1734 form_end_group(f, args)
1735         formobject *f;
1736         PyObject *args;
1737 {
1738         fl_addto_form(f-> ob_form);
1739         fl_end_group();
1740         fl_end_form();
1741         Py_INCREF(Py_None);
1742         return Py_None;
1743 }
1744
1745 static PyObject *
1746 forms_find_first_or_last(func, f, args)
1747         FL_OBJECT *(*func)(FL_FORM *, int, float, float);
1748         formobject *f;
1749         PyObject *args;
1750 {
1751         int type;
1752         float mx, my;
1753         FL_OBJECT *generic;
1754         genericobject *g;
1755
1756         if (!PyArg_Parse(args, "(iff)", &type, &mx, &my)) return NULL;
1757
1758         generic = (*func) (f-> ob_form, type, mx, my);
1759
1760         if (generic == NULL)
1761         {
1762                 Py_INCREF(Py_None);
1763                 return Py_None;
1764         }
1765
1766         g = findgeneric(generic);
1767         if (g == NULL) {
1768                 PyErr_SetString(PyExc_RuntimeError,
1769                            "forms_find_{first|last} returns unknown object");
1770                 return NULL;
1771         }
1772         Py_INCREF(g);
1773         return (PyObject *) g;
1774 }
1775
1776 static PyObject *
1777 form_find_first(f, args)
1778         formobject *f;
1779         PyObject *args;
1780 {
1781         return forms_find_first_or_last(fl_find_first, f, args);
1782 }
1783
1784 static PyObject *
1785 form_find_last(f, args)
1786         formobject *f;
1787         PyObject *args;
1788 {
1789         return forms_find_first_or_last(fl_find_last, f, args);
1790 }
1791
1792 static PyObject *
1793 form_set_object_focus(f, args)
1794         formobject *f;
1795         PyObject *args;
1796 {
1797         genericobject *g;
1798         if (args == NULL || !is_genericobject(args)) {
1799                 PyErr_BadArgument();
1800                 return NULL;
1801         }
1802         g = (genericobject *)args;
1803         fl_set_object_focus(f->ob_form, g->ob_generic);
1804         Py_INCREF(Py_None);
1805         return Py_None;
1806 }
1807
1808 static PyMethodDef form_methods[] = {
1809 /* adm */
1810         {"show_form",           (PyCFunction)form_show_form},
1811         {"hide_form",           (PyCFunction)form_hide_form},
1812         {"redraw_form",         (PyCFunction)form_redraw_form},
1813         {"set_form_position",   (PyCFunction)form_set_form_position},
1814         {"set_form_size",       (PyCFunction)form_set_form_size},
1815         {"scale_form",          (PyCFunction)form_scale_form},
1816         {"freeze_form",         (PyCFunction)form_freeze_form},
1817         {"unfreeze_form",       (PyCFunction)form_unfreeze_form},
1818         {"activate_form",       (PyCFunction)form_activate_form},
1819         {"deactivate_form",     (PyCFunction)form_deactivate_form},
1820         {"bgn_group",           (PyCFunction)form_bgn_group},
1821         {"end_group",           (PyCFunction)form_end_group},
1822         {"find_first",          (PyCFunction)form_find_first},
1823         {"find_last",           (PyCFunction)form_find_last},
1824         {"set_object_focus",    (PyCFunction)form_set_object_focus},
1825
1826 /* basic objects */
1827         {"add_button",          (PyCFunction)form_add_button},
1828 /*      {"add_bitmap",          (method)form_add_bitmap}, */
1829         {"add_lightbutton",     (PyCFunction)form_add_lightbutton},
1830         {"add_roundbutton",     (PyCFunction)form_add_roundbutton},
1831         {"add_menu",            (PyCFunction)form_add_menu},
1832         {"add_slider",          (PyCFunction)form_add_slider},
1833         {"add_positioner",      (PyCFunction)form_add_positioner},
1834         {"add_valslider",       (PyCFunction)form_add_valslider},
1835         {"add_dial",            (PyCFunction)form_add_dial},
1836         {"add_counter",         (PyCFunction)form_add_counter},
1837         {"add_box",             (PyCFunction)form_add_box},
1838         {"add_clock",           (PyCFunction)form_add_clock},
1839         {"add_choice",          (PyCFunction)form_add_choice},
1840         {"add_browser",         (PyCFunction)form_add_browser},
1841         {"add_input",           (PyCFunction)form_add_input},
1842         {"add_timer",           (PyCFunction)form_add_timer},
1843         {"add_text",            (PyCFunction)form_add_text},
1844         {NULL,                  NULL}           /* sentinel */
1845 };
1846
1847 static void
1848 form_dealloc(f)
1849         formobject *f;
1850 {
1851         releaseobjects(f->ob_form);
1852         if (f->ob_form->visible)
1853                 fl_hide_form(f->ob_form);
1854         fl_free_form(f->ob_form);
1855         PyMem_DEL(f);
1856 }
1857
1858 #define OFF(x) offsetof(FL_FORM, x)
1859
1860 static struct memberlist form_memberlist[] = {
1861         {"window",      T_LONG,         OFF(window),    RO},
1862         {"w",           T_FLOAT,        OFF(w)},
1863         {"h",           T_FLOAT,        OFF(h)},
1864         {"x",           T_FLOAT,        OFF(x),         RO},
1865         {"y",           T_FLOAT,        OFF(y),         RO},
1866         {"deactivated", T_INT,          OFF(deactivated)},
1867         {"visible",     T_INT,          OFF(visible),   RO},
1868         {"frozen",      T_INT,          OFF(frozen),    RO},
1869         {"doublebuf",   T_INT,          OFF(doublebuf)},
1870         {NULL}  /* Sentinel */
1871 };
1872
1873 #undef OFF
1874
1875 static PyObject *
1876 form_getattr(f, name)
1877         formobject *f;
1878         char *name;
1879 {
1880         PyObject *meth;
1881
1882         meth = Py_FindMethod(form_methods, (PyObject *)f, name);
1883         if (meth != NULL)
1884                 return meth;
1885         PyErr_Clear();
1886         return PyMember_Get((char *)f->ob_form, form_memberlist, name);
1887 }
1888
1889 static int
1890 form_setattr(f, name, v)
1891         formobject *f;
1892         char *name;
1893         PyObject *v;
1894 {
1895         if (v == NULL) {
1896                 PyErr_SetString(PyExc_TypeError,
1897                                 "can't delete form attributes");
1898                 return -1;
1899         }
1900
1901         return PyMember_Set((char *)f->ob_form, form_memberlist, name, v);
1902 }
1903
1904 static PyObject *
1905 form_repr(f)
1906         formobject *f;
1907 {
1908         char buf[100];
1909         sprintf(buf, "<FORMS_form at %lx, window=%ld>",
1910                 (long)f, f->ob_form->window);
1911         return PyString_FromString(buf);
1912 }
1913
1914 static PyTypeObject Formtype = {
1915         PyObject_HEAD_INIT(&PyType_Type)
1916         0,                              /*ob_size*/
1917         "FORMS_form",                   /*tp_name*/
1918         sizeof(formobject),             /*tp_size*/
1919         0,                              /*tp_itemsize*/
1920         /* methods */
1921         (destructor)form_dealloc,       /*tp_dealloc*/
1922         0,                              /*tp_print*/
1923         (getattrfunc)form_getattr,      /*tp_getattr*/
1924         (setattrfunc)form_setattr,      /*tp_setattr*/
1925         0,                              /*tp_compare*/
1926         (reprfunc)form_repr,            /*tp_repr*/
1927 };
1928
1929 static PyObject *
1930 newformobject(form)
1931         FL_FORM *form;
1932 {
1933         formobject *f;
1934         f = PyObject_NEW(formobject, &Formtype);
1935         if (f == NULL)
1936                 return NULL;
1937         f->ob_form = form;
1938         return (PyObject *)f;
1939 }
1940
1941
1942 /* The "fl" module */
1943
1944 static PyObject *
1945 forms_make_form(dummy, args)
1946         PyObject *dummy;
1947         PyObject *args;
1948 {
1949         int type;
1950         float w, h;
1951         FL_FORM *form;
1952         if (!PyArg_Parse(args, "(iff)", &type, &w, &h))
1953                 return NULL;
1954         form = fl_bgn_form(type, w, h);
1955         if (form == NULL) {
1956                 /* XXX Actually, cannot happen! */
1957                 PyErr_NoMemory();
1958                 return NULL;
1959         }
1960         fl_end_form();
1961         return newformobject(form);
1962 }
1963
1964 static PyObject *
1965 forms_activate_all_forms(f, args)
1966         PyObject *f;
1967         PyObject *args;
1968 {
1969         fl_activate_all_forms();
1970         Py_INCREF(Py_None);
1971         return Py_None;
1972 }
1973
1974 static PyObject *
1975 forms_deactivate_all_forms(f, args)
1976         PyObject *f;
1977         PyObject *args;
1978 {
1979         fl_deactivate_all_forms();
1980         Py_INCREF(Py_None);
1981         return Py_None;
1982 }
1983
1984 static PyObject *my_event_callback = NULL;
1985
1986 static PyObject *
1987 forms_set_event_call_back(dummy, args)
1988         PyObject *dummy;
1989         PyObject *args;
1990 {
1991         if (args == Py_None)
1992                 args = NULL;
1993         my_event_callback = args;
1994         Py_XINCREF(args);
1995         Py_INCREF(Py_None);
1996         return Py_None;
1997 }
1998
1999 static PyObject *
2000 forms_do_or_check_forms(dummy, args, func)
2001         PyObject *dummy;
2002         PyObject *args;
2003         FL_OBJECT *(*func)();
2004 {
2005         FL_OBJECT *generic;
2006         genericobject *g;
2007         PyObject *arg, *res;
2008
2009         if (!PyArg_NoArgs(args))
2010                 return NULL;
2011
2012         for (;;) {
2013                 Py_BEGIN_ALLOW_THREADS
2014                 generic = (*func)();
2015                 Py_END_ALLOW_THREADS
2016                 if (generic == NULL) {
2017                         Py_INCREF(Py_None);
2018                         return Py_None;
2019                 }
2020                 if (generic == FL_EVENT) {
2021                         int dev;
2022                         short val;
2023                         if (my_event_callback == NULL)
2024                                 return PyInt_FromLong(-1L);
2025                         dev = fl_qread(&val);
2026                         arg = Py_BuildValue("(ih)", dev, val);
2027                         if (arg == NULL)
2028                                 return NULL;
2029                         res = PyEval_CallObject(my_event_callback, arg);
2030                         Py_XDECREF(res);
2031                         Py_DECREF(arg);
2032                         if (res == NULL)
2033                                 return NULL; /* Callback raised exception */
2034                         continue;
2035                 }
2036                 g = findgeneric(generic);
2037                 if (g == NULL) {
2038                         /* Object not known to us (some dialogs cause this) */
2039                         continue; /* Ignore it */
2040                 }
2041                 if (g->ob_callback == NULL) {
2042                         Py_INCREF(g);
2043                         return ((PyObject *) g);
2044                 }
2045                 arg = Py_BuildValue("(OO)", (PyObject *)g, g->ob_callback_arg);
2046                 if (arg == NULL)
2047                         return NULL;
2048                 res = PyEval_CallObject(g->ob_callback, arg);
2049                 Py_XDECREF(res);
2050                 Py_DECREF(arg);
2051                 if (res == NULL)
2052                         return NULL; /* Callback raised exception */
2053         }
2054 }
2055
2056 static PyObject *
2057 forms_do_forms(dummy, args)
2058         PyObject *dummy;
2059         PyObject *args;
2060 {
2061         return forms_do_or_check_forms(dummy, args, fl_do_forms);
2062 }
2063
2064 static PyObject *
2065 forms_check_forms(dummy, args)
2066         PyObject *dummy;
2067         PyObject *args;
2068 {
2069         return forms_do_or_check_forms(dummy, args, fl_check_forms);
2070 }
2071
2072 static PyObject *
2073 forms_do_only_forms(dummy, args)
2074         PyObject *dummy;
2075         PyObject *args;
2076 {
2077         return forms_do_or_check_forms(dummy, args, fl_do_only_forms);
2078 }
2079
2080 static PyObject *
2081 forms_check_only_forms(dummy, args)
2082         PyObject *dummy;
2083         PyObject *args;
2084 {
2085         return forms_do_or_check_forms(dummy, args, fl_check_only_forms);
2086 }
2087
2088 #ifdef UNUSED
2089 static PyObject *
2090 fl_call(func, args)
2091         PyObject *args;
2092         void (*func)();
2093 {
2094         if (!PyArg_NoArgs(args))
2095                 return NULL;
2096         (*func)();
2097         Py_INCREF(Py_None);
2098         return Py_None;
2099 }
2100 #endif
2101
2102 static PyObject *
2103 forms_set_graphics_mode(dummy, args)
2104         PyObject *dummy;
2105         PyObject *args;
2106 {
2107         int rgbmode, doublebuf;
2108
2109         if (!PyArg_Parse(args, "(ii)", &rgbmode, &doublebuf))
2110                 return NULL;
2111         fl_set_graphics_mode(rgbmode,doublebuf);
2112         Py_INCREF(Py_None);
2113         return Py_None;
2114 }
2115
2116 static PyObject *
2117 forms_get_rgbmode(dummy, args)
2118         PyObject *dummy;
2119         PyObject *args;
2120 {
2121         extern int fl_rgbmode;
2122
2123         if (args != NULL) {
2124                 PyErr_BadArgument();
2125                 return NULL;
2126         }
2127         return PyInt_FromLong((long)fl_rgbmode);
2128 }
2129
2130 static PyObject *
2131 forms_show_errors(dummy, args)
2132         PyObject *dummy;
2133         PyObject *args;
2134 {
2135         int show;
2136         if (!PyArg_Parse(args, "i", &show))
2137                 return NULL;
2138         fl_show_errors(show);
2139         Py_INCREF(Py_None);
2140         return Py_None;
2141 }
2142
2143 static PyObject *
2144 forms_set_font_name(dummy, args)
2145         PyObject *dummy;
2146         PyObject *args;
2147 {
2148         int numb;
2149         char *name;
2150         if (!PyArg_Parse(args, "(is)", &numb, &name))
2151                 return NULL;
2152         fl_set_font_name(numb, name);
2153         Py_INCREF(Py_None);
2154         return Py_None;
2155 }
2156
2157
2158 static PyObject *
2159 forms_qdevice(self, args)
2160         PyObject *self;
2161         PyObject *args;
2162 {
2163         short arg1;
2164         if (!PyArg_Parse(args, "h", &arg1))
2165                 return NULL;
2166         fl_qdevice(arg1);
2167         Py_INCREF(Py_None);
2168         return Py_None;
2169 }
2170
2171 static PyObject *
2172 forms_unqdevice(self, args)
2173         PyObject *self;
2174         PyObject *args;
2175 {
2176         short arg1;
2177         if (!PyArg_Parse(args, "h", &arg1))
2178                 return NULL;
2179         fl_unqdevice(arg1);
2180         Py_INCREF(Py_None);
2181         return Py_None;
2182 }
2183
2184 static PyObject *
2185 forms_isqueued(self, args)
2186         PyObject *self;
2187         PyObject *args;
2188 {
2189         long retval;
2190         short arg1;
2191         if (!PyArg_Parse(args, "h", &arg1))
2192                 return NULL;
2193         retval = fl_isqueued(arg1);
2194
2195         return PyInt_FromLong(retval);
2196 }
2197
2198 static PyObject *
2199 forms_qtest(self, args)
2200         PyObject *self;
2201         PyObject *args;
2202 {
2203         long retval;
2204         retval = fl_qtest();
2205         return PyInt_FromLong(retval);
2206 }
2207
2208
2209 static PyObject *
2210 forms_qread(self, args)
2211         PyObject *self;
2212         PyObject *args;
2213 {
2214         int dev;
2215         short val;
2216         Py_BEGIN_ALLOW_THREADS
2217         dev = fl_qread(&val);
2218         Py_END_ALLOW_THREADS
2219         return Py_BuildValue("(ih)", dev, val);
2220 }
2221
2222 static PyObject *
2223 forms_qreset(self, args)
2224         PyObject *self;
2225         PyObject *args;
2226 {
2227         if (!PyArg_NoArgs(args)) return NULL;
2228
2229         fl_qreset();
2230         Py_INCREF(Py_None);
2231         return Py_None;
2232 }
2233
2234 static PyObject *
2235 forms_qenter(self, args)
2236         PyObject *self;
2237         PyObject *args;
2238 {
2239         short arg1, arg2;
2240         if (!PyArg_Parse(args, "(hh)", &arg1, &arg2))
2241                 return NULL;
2242         fl_qenter(arg1, arg2);
2243         Py_INCREF(Py_None);
2244         return Py_None;
2245 }
2246
2247 static PyObject *
2248 forms_color(self, args)
2249         PyObject *self;
2250         PyObject *args;
2251 {
2252         int arg;
2253
2254         if (!PyArg_Parse(args, "i", &arg)) return NULL;
2255
2256         fl_color((short) arg);
2257
2258         Py_INCREF(Py_None);
2259         return Py_None;
2260 }
2261
2262 static PyObject *
2263 forms_mapcolor(self, args)
2264         PyObject *self;
2265         PyObject *args;
2266 {
2267         int arg0, arg1, arg2, arg3;
2268
2269         if (!PyArg_Parse(args, "(iiii)", &arg0, &arg1, &arg2, &arg3))
2270                 return NULL;
2271
2272         fl_mapcolor(arg0, (short) arg1, (short) arg2, (short) arg3);
2273
2274         Py_INCREF(Py_None);
2275         return Py_None;
2276 }
2277
2278 static PyObject *
2279 forms_getmcolor(self, args)
2280         PyObject *self;
2281         PyObject *args;
2282 {
2283         int arg;
2284         short r, g, b;
2285
2286         if (!PyArg_Parse(args, "i", &arg)) return NULL;
2287
2288         fl_getmcolor(arg, &r, &g, &b);
2289
2290         return Py_BuildValue("(hhh)", r, g, b);
2291 }
2292
2293 static PyObject *
2294 forms_get_mouse(self, args)
2295         PyObject *self;
2296         PyObject *args;
2297 {
2298         float x, y;
2299
2300         if (!PyArg_NoArgs(args)) return NULL;
2301
2302         fl_get_mouse(&x, &y);
2303
2304         return Py_BuildValue("(ff)", x, y);
2305 }
2306
2307 static PyObject *
2308 forms_tie(self, args)
2309         PyObject *self;
2310         PyObject *args;
2311 {
2312         short arg1, arg2, arg3;
2313         if (!PyArg_Parse(args, "(hhh)", &arg1, &arg2, &arg3))
2314                 return NULL;
2315         fl_tie(arg1, arg2, arg3);
2316         Py_INCREF(Py_None);
2317         return Py_None;
2318 }
2319
2320 static PyObject *
2321 forms_show_message(f, args)
2322         PyObject *f;
2323         PyObject *args;
2324 {
2325         char *a, *b, *c;
2326
2327         if (!PyArg_Parse(args, "(sss)", &a, &b, &c)) return NULL;
2328
2329         Py_BEGIN_ALLOW_THREADS
2330         fl_show_message(a, b, c);
2331         Py_END_ALLOW_THREADS
2332
2333         Py_INCREF(Py_None);
2334         return Py_None;
2335 }
2336
2337 static PyObject *
2338 forms_show_choice(f, args)
2339         PyObject *f;
2340         PyObject *args;
2341 {
2342         char *m1, *m2, *m3, *b1, *b2, *b3;
2343         int nb;
2344         char *format;
2345         long rv;
2346
2347         if (args == NULL || !PyTuple_Check(args)) {
2348                 PyErr_BadArgument();
2349                 return NULL;
2350         }
2351         nb = PyTuple_Size(args) - 3;
2352         if (nb <= 0) {
2353                 PyErr_SetString(PyExc_TypeError,
2354                                 "need at least one button label");
2355                 return NULL;
2356         }
2357         if (PyInt_Check(PyTuple_GetItem(args, 3))) {
2358                 PyErr_SetString(PyExc_TypeError,
2359                            "'number-of-buttons' argument not needed");
2360                 return NULL;
2361         }
2362         switch (nb) {
2363         case 1: format = "(ssss)"; break;
2364         case 2: format = "(sssss)"; break;
2365         case 3: format = "(ssssss)"; break;
2366         default:
2367                 PyErr_SetString(PyExc_TypeError, "too many button labels");
2368                 return NULL;
2369         }
2370
2371         if (!PyArg_Parse(args, format, &m1, &m2, &m3, &b1, &b2, &b3))
2372                 return NULL;
2373
2374         Py_BEGIN_ALLOW_THREADS
2375         rv = fl_show_choice(m1, m2, m3, nb, b1, b2, b3);
2376         Py_END_ALLOW_THREADS
2377         return PyInt_FromLong(rv);
2378 }
2379
2380 static PyObject *
2381 forms_show_question(f, args)
2382         PyObject *f;
2383         PyObject *args;
2384 {
2385         int ret;
2386         char *a, *b, *c;
2387
2388         if (!PyArg_Parse(args, "(sss)", &a, &b, &c)) return NULL;
2389
2390         Py_BEGIN_ALLOW_THREADS
2391         ret = fl_show_question(a, b, c);
2392         Py_END_ALLOW_THREADS
2393
2394         return PyInt_FromLong((long) ret);
2395 }
2396
2397 static PyObject *
2398 forms_show_input(f, args)
2399         PyObject *f;
2400         PyObject *args;
2401 {
2402         char *str;
2403         char *a, *b;
2404
2405         if (!PyArg_Parse(args, "(ss)", &a, &b)) return NULL;
2406
2407         Py_BEGIN_ALLOW_THREADS
2408         str = fl_show_input(a, b);
2409         Py_END_ALLOW_THREADS
2410
2411         if (str == NULL) {
2412                 Py_INCREF(Py_None);
2413                 return Py_None;
2414         }
2415         return PyString_FromString(str);
2416 }
2417
2418 static PyObject *
2419 forms_file_selector(f, args)
2420         PyObject *f;
2421         PyObject *args;
2422 {
2423         char *str;
2424         char *a, *b, *c, *d;
2425
2426         if (!PyArg_Parse(args, "(ssss)", &a, &b, &c, &d)) return NULL;
2427
2428         Py_BEGIN_ALLOW_THREADS
2429         str = fl_show_file_selector(a, b, c, d);
2430         Py_END_ALLOW_THREADS
2431
2432         if (str == NULL) {
2433                 Py_INCREF(Py_None);
2434                 return Py_None;
2435         }
2436         return PyString_FromString(str);
2437 }
2438
2439
2440 static PyObject *
2441 forms_file_selector_func(args, func)
2442         PyObject *args;
2443         char *(*func)();
2444 {
2445         char *str;
2446
2447         str = (*func) ();
2448
2449         if (str == NULL) {
2450                 Py_INCREF(Py_None);
2451                 return Py_None;
2452         }
2453         return PyString_FromString(str);
2454 }
2455
2456 static PyObject *
2457 forms_get_directory(f, args)
2458         PyObject *f;
2459         PyObject *args;
2460 {
2461         return forms_file_selector_func(args, fl_get_directory);
2462 }
2463
2464 static PyObject *
2465 forms_get_pattern(f, args)
2466         PyObject *f;
2467         PyObject *args;
2468 {
2469         return forms_file_selector_func(args, fl_get_pattern);
2470 }
2471
2472 static PyObject *
2473 forms_get_filename(f, args)
2474         PyObject *f;
2475         PyObject *args;
2476 {
2477         return forms_file_selector_func(args, fl_get_filename);
2478 }
2479
2480 static PyMethodDef forms_methods[] = {
2481 /* adm */
2482         {"make_form",           forms_make_form},
2483         {"activate_all_forms",  forms_activate_all_forms},
2484         {"deactivate_all_forms",forms_deactivate_all_forms},
2485 /* gl support wrappers */
2486         {"qdevice",             forms_qdevice},
2487         {"unqdevice",           forms_unqdevice},
2488         {"isqueued",            forms_isqueued},
2489         {"qtest",               forms_qtest},
2490         {"qread",               forms_qread},
2491 /*      {"blkqread",            forms_blkqread}, */
2492         {"qreset",              forms_qreset},
2493         {"qenter",              forms_qenter},
2494         {"get_mouse",           forms_get_mouse},
2495         {"tie",                 forms_tie},
2496 /*      {"new_events",          forms_new_events}, */
2497         {"color",               forms_color},
2498         {"mapcolor",            forms_mapcolor},
2499         {"getmcolor",           forms_getmcolor},
2500 /* interaction */
2501         {"do_forms",            forms_do_forms},
2502         {"do_only_forms",       forms_do_only_forms},
2503         {"check_forms",         forms_check_forms},
2504         {"check_only_forms",    forms_check_only_forms},
2505         {"set_event_call_back", forms_set_event_call_back},
2506 /* goodies */
2507         {"show_message",        forms_show_message},
2508         {"show_question",       forms_show_question},
2509         {"show_choice",         forms_show_choice},
2510         {"show_input",          forms_show_input},
2511         {"show_file_selector",  forms_file_selector},
2512         {"file_selector",       forms_file_selector}, /* BW compat */
2513         {"get_directory",       forms_get_directory},
2514         {"get_pattern",         forms_get_pattern},
2515         {"get_filename",        forms_get_filename},
2516         {"set_graphics_mode",   forms_set_graphics_mode},
2517         {"get_rgbmode",         forms_get_rgbmode},
2518         {"show_errors",         forms_show_errors},
2519         {"set_font_name",       forms_set_font_name},
2520         {NULL,                  NULL}           /* sentinel */
2521 };
2522
2523 DL_EXPORT(void)
2524 initfl()
2525 {
2526         Py_InitModule("fl", forms_methods);
2527         foreground();
2528         fl_init();
2529 }
2530
2531
2532