Modules/flmodule.c

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