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