Modules/flmodule.c

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