]> git.ipfire.org Git - thirdparty/newt.git/blame - snackmodule.c
projects / thirdparty / newt.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Release 0.50.9
[thirdparty/newt.git] / snackmodule.c
CommitLineData
80d03bd8 1#include <errno.h>
2#include <fcntl.h>
3#include <sys/stat.h>
4#include <sys/time.h>
5#include <unistd.h>
6
7#include "Python.h"
8#include "newt.h"
9
10typedef struct snackWidget_s snackWidget;
11typedef struct snackGrid_s snackGrid;
12typedef struct snackForm_s snackForm;
13
5d678658 14struct callbackStruct {
06cf519e 15 PyObject * cb, * data;
16};
17
1dfa0cfa 18static struct callbackStruct suspend;
19
80d03bd8 20static void emptyDestructor(PyObject * s);
21
22static snackWidget * buttonWidget(PyObject * s, PyObject * args);
23static PyObject * centeredWindow(PyObject * s, PyObject * args);
24static snackWidget * checkboxWidget(PyObject * s, PyObject * args);
25static PyObject * choiceWindow(PyObject * s, PyObject * args);
26static snackWidget * entryWidget(PyObject * s, PyObject * args);
75fb0452 27static PyObject * drawRootText(PyObject * s, PyObject * args);
f1aef30b 28static PyObject * doResume(PyObject * s, PyObject * args);
29static PyObject * doSuspend(PyObject * s, PyObject * args);
30static PyObject * doSuspend(PyObject * s, PyObject * args);
80d03bd8 31static snackForm * formCreate(PyObject * s, PyObject * args);
32static snackGrid * gridCreate(PyObject * s, PyObject * args);
33static PyObject * gridWrappedWindow(PyObject * s, PyObject * args);
34static PyObject * finishScreen(PyObject * s, PyObject * args);
35static PyObject * initScreen(PyObject * s, PyObject * args);
36static snackWidget * labelWidget(PyObject * s, PyObject * args);
6e25d997 37static snackWidget * listboxWidget(PyObject * s, PyObject * args);
80d03bd8 38static PyObject * messageWindow(PyObject * s, PyObject * args);
39static PyObject * openWindow(PyObject * s, PyObject * args);
75fb0452 40static PyObject * popHelpLine(PyObject * s, PyObject * args);
80d03bd8 41static PyObject * popWindow(PyObject * s, PyObject * args);
75fb0452 42static PyObject * pushHelpLine(PyObject * s, PyObject * args);
80d03bd8 43static snackWidget * radioButtonWidget(PyObject * s, PyObject * args);
44static PyObject * refreshScreen(PyObject * s, PyObject * args);
06cf519e 45static PyObject * scaleWidget(PyObject * s, PyObject * args);
46static PyObject * scaleSet(snackWidget * s, PyObject * args);
9f0ab2ac 47static PyObject * screenSize(PyObject * s, PyObject * args);
06cf519e 48static PyObject * setSuspendCallback(PyObject * s, PyObject * args);
6e25d997 49static PyObject * reflowText(PyObject * s, PyObject * args);
50static snackWidget * textWidget(PyObject * s, PyObject * args);
80d03bd8 51static PyObject * ternaryWindow(PyObject * s, PyObject * args);
f06c5a99 52static snackWidget * checkboxTreeWidget(PyObject * s, PyObject * args);
80d03bd8 53
54static PyMethodDef snackModuleMethods[] = {
55 { "button", (PyCFunction) buttonWidget, METH_VARARGS, NULL },
56 { "checkbox", (PyCFunction) checkboxWidget, METH_VARARGS, NULL },
57 { "choice", choiceWindow, METH_VARARGS, NULL },
58 { "centeredwindow", centeredWindow, METH_VARARGS, NULL },
75fb0452 59 { "drawroottext", drawRootText, METH_VARARGS, NULL },
80d03bd8 60 { "entry", (PyCFunction) entryWidget, METH_VARARGS, NULL },
61 { "finish", finishScreen, METH_VARARGS, NULL },
62 { "form", (PyCFunction) formCreate, METH_VARARGS, NULL },
63 { "grid", (PyCFunction) gridCreate, METH_VARARGS, NULL },
64 { "gridwrappedwindow", gridWrappedWindow, METH_VARARGS, NULL },
65 { "init", initScreen, METH_VARARGS, NULL },
66 { "label", (PyCFunction) labelWidget, METH_VARARGS, NULL },
6e25d997 67 { "listbox", (PyCFunction) listboxWidget, METH_VARARGS, NULL },
80d03bd8 68 { "message", messageWindow, METH_VARARGS, NULL },
69 { "openwindow", openWindow, METH_VARARGS, NULL },
75fb0452 70 { "pophelpline", popHelpLine, METH_VARARGS, NULL },
80d03bd8 71 { "popwindow", popWindow, METH_VARARGS, NULL },
75fb0452 72 { "pushhelpline", pushHelpLine, METH_VARARGS, NULL },
80d03bd8 73 { "radiobutton", (PyCFunction) radioButtonWidget, METH_VARARGS, NULL },
6e25d997 74 { "reflow", (PyCFunction) reflowText, METH_VARARGS, NULL },
80d03bd8 75 { "refresh", refreshScreen, METH_VARARGS, NULL },
f1aef30b 76 { "resume", doResume, METH_VARARGS, NULL },
06cf519e 77 { "scale", scaleWidget, METH_VARARGS, NULL },
9f0ab2ac 78 { "size", screenSize, METH_VARARGS, NULL },
f1aef30b 79 { "suspend", doSuspend, METH_VARARGS, NULL },
06cf519e 80 { "suspendcallback", setSuspendCallback, METH_VARARGS, NULL },
80d03bd8 81 { "ternary", ternaryWindow, METH_VARARGS, NULL },
6e25d997 82 { "textbox", (PyCFunction) textWidget, METH_VARARGS, NULL },
f06c5a99 83 { "checkboxtree", (PyCFunction) checkboxTreeWidget, METH_VARARGS, NULL },
80d03bd8 84 { NULL }
85} ;
86
87struct snackGrid_s {
88 PyObject_HEAD;
89 newtGrid grid;
90} ;
91
92static PyObject * gridGetAttr(PyObject * s, char * name);
93static PyObject * gridPlace(snackGrid * s, PyObject * args);
94static PyObject * gridSetField(snackGrid * s, PyObject * args);
95
96static PyMethodDef gridMethods[] = {
97 { "place", (PyCFunction) gridPlace, METH_VARARGS, NULL },
98 { "setfield", (PyCFunction) gridSetField, METH_VARARGS, NULL },
99 { NULL }
100};
101
102static PyTypeObject snackGridType = {
103 PyObject_HEAD_INIT(&PyType_Type)
104 0, /* ob_size */
105 "snackgrid", /* tp_name */
106 sizeof(snackGrid), /* tp_size */
107 0, /* tp_itemsize */
108 emptyDestructor, /* tp_dealloc */
109 0, /* tp_print */
110 gridGetAttr, /* tp_getattr */
111 0, /* tp_setattr */
112 0, /* tp_compare */
113 0, /* tp_repr */
114 0, /* tp_as_number */
115 0, /* tp_as_sequence */
116 0, /* tp_as_mapping */
117};
118
119struct snackForm_s {
120 PyObject_HEAD;
121 newtComponent fo;
122} ;
123
124static PyObject * formGetAttr(PyObject * s, char * name);
125static PyObject * formAdd(snackForm * s, PyObject * args);
bd38d47e 126static PyObject * formDraw(snackForm * s, PyObject * args);
80d03bd8 127static PyObject * formRun(snackForm * s, PyObject * args);
ea59ae12 128static PyObject * formHotKey(snackForm * s, PyObject * args);
5d678658 129static PyObject * formSetCurrent(snackForm * form, PyObject * args);
73390860 130static PyObject * formSetTimer(snackForm * form, PyObject * args);
80d03bd8 131
132static PyMethodDef formMethods[] = {
133 { "add", (PyCFunction) formAdd, METH_VARARGS, NULL },
bd38d47e 134 { "draw", (PyCFunction) formDraw, METH_VARARGS, NULL },
80d03bd8 135 { "run", (PyCFunction) formRun, METH_VARARGS, NULL },
ea59ae12 136 { "addhotkey", (PyCFunction) formHotKey, METH_VARARGS, NULL },
5d678658 137 { "setcurrent", (PyCFunction) formSetCurrent, METH_VARARGS, NULL },
73390860 138 { "settimer", (PyCFunction) formSetTimer, METH_VARARGS, NULL },
80d03bd8 139 { NULL }
140};
141
142static PyTypeObject snackFormType = {
143 PyObject_HEAD_INIT(&PyType_Type)
144 0, /* ob_size */
145 "snackform", /* tp_name */
146 sizeof(snackForm), /* tp_size */
147 0, /* tp_itemsize */
148 emptyDestructor, /* tp_dealloc */
149 0, /* tp_print */
150 formGetAttr, /* tp_getattr */
151 0, /* tp_setattr */
152 0, /* tp_compare */
153 0, /* tp_repr */
154 0, /* tp_as_number */
155 0, /* tp_as_sequence */
156 0, /* tp_as_mapping */
157};
158
159struct snackWidget_s {
160 PyObject_HEAD;
161 newtComponent co;
162 char achar;
163 void * apointer;
6e25d997 164 int anint;
5d678658 165 struct callbackStruct scs;
80d03bd8 166} ;
167
6a703ca8 168static PyObject * widgetAddCallback(snackWidget * s, PyObject * args);
80d03bd8 169static PyObject * widgetGetAttr(PyObject * s, char * name);
1dfa0cfa 170static void widgetDestructor(PyObject * s);
80d03bd8 171static PyObject * widgetEntrySetValue(snackWidget * s, PyObject * args);
522d3500 172static PyObject * widgetLabelText(snackWidget * s, PyObject * args);
6e25d997 173static PyObject * widgetListboxSetW(snackWidget * s, PyObject * args);
174static PyObject * widgetListboxAdd(snackWidget * s, PyObject * args);
a507b3ec 175static PyObject * widgetListboxIns(snackWidget * s, PyObject * args);
176static PyObject * widgetListboxDel(snackWidget * s, PyObject * args);
6e25d997 177static PyObject * widgetListboxGet(snackWidget * s, PyObject * args);
99438c19 178static PyObject * widgetListboxSet(snackWidget * s, PyObject * args);
36f926a6 179static PyObject * widgetTextboxText(snackWidget * s, PyObject * args);
75d40644 180static PyObject * widgetCheckboxTreeAddItem(snackWidget * s, PyObject * args);
5d678658 181static PyObject * widgetCheckboxTreeGetSel(snackWidget * s, PyObject * args);
2b6641b1 182static PyObject * widgetCheckboxTreeGetCur(snackWidget * s, PyObject * args);
c895490d 183static PyObject * widgetCheckboxTreeSetEntry(snackWidget * s, PyObject * args);
184static PyObject * widgetCheckboxTreeSetEntryValue(snackWidget * s, PyObject * args);
185static PyObject * widgetCheckboxTreeGetEntryValue(snackWidget * s, PyObject * args);
5d678658 186static PyObject * widgetEntrySetFlags(snackWidget * s, PyObject * args);
c573c71b 187static PyObject * widgetCheckboxSetFlags(snackWidget * s, PyObject * args);
80d03bd8 188
189static PyMethodDef widgetMethods[] = {
6a703ca8 190 { "setCallback", (PyCFunction) widgetAddCallback, METH_VARARGS, NULL },
522d3500 191 { "labelText", (PyCFunction) widgetLabelText, METH_VARARGS, NULL },
36f926a6 192 { "textboxText", (PyCFunction) widgetTextboxText, METH_VARARGS, NULL },
80d03bd8 193 { "entrySetValue", (PyCFunction) widgetEntrySetValue, METH_VARARGS, NULL },
6e25d997 194 { "listboxAddItem", (PyCFunction) widgetListboxAdd, METH_VARARGS, NULL },
a507b3ec 195 { "listboxInsertItem", (PyCFunction) widgetListboxIns, METH_VARARGS, NULL },
6e25d997 196 { "listboxGetCurrent", (PyCFunction) widgetListboxGet, METH_VARARGS, NULL },
99438c19 197 { "listboxSetCurrent", (PyCFunction) widgetListboxSet, METH_VARARGS, NULL },
6e25d997 198 { "listboxSetWidth", (PyCFunction) widgetListboxSetW, METH_VARARGS, NULL },
a507b3ec 199 { "listboxDeleteItem", (PyCFunction) widgetListboxDel, METH_VARARGS, NULL },
06cf519e 200 { "scaleSet", (PyCFunction) scaleSet, METH_VARARGS, NULL },
75d40644 201 { "checkboxtreeAddItem", (PyCFunction) widgetCheckboxTreeAddItem,
f06c5a99 202 METH_VARARGS, NULL },
2b6641b1 203 { "checkboxtreeGetCurrent", (PyCFunction) widgetCheckboxTreeGetCur,
204 METH_VARARGS, NULL },
c895490d 205 { "checkboxtreeGetEntryValue", (PyCFunction) widgetCheckboxTreeGetEntryValue,
206 METH_VARARGS, NULL },
207 { "checkboxtreeSetEntry", (PyCFunction) widgetCheckboxTreeSetEntry,
208 METH_VARARGS, NULL },
209 { "checkboxtreeSetEntryValue", (PyCFunction) widgetCheckboxTreeSetEntryValue,
210 METH_VARARGS, NULL },
f06c5a99 211 { "checkboxtreeGetSelection", (PyCFunction) widgetCheckboxTreeGetSel,
212 METH_VARARGS, NULL },
5d678658 213 { "entrySetFlags", (PyCFunction) widgetEntrySetFlags, METH_VARARGS, NULL },
c573c71b 214 { "checkboxSetFlags", (PyCFunction) widgetCheckboxSetFlags, METH_VARARGS, NULL },
80d03bd8 215 { NULL }
216};
217
218static PyTypeObject snackWidgetType = {
219 PyObject_HEAD_INIT(&PyType_Type)
220 0, /* ob_size */
221 "snackwidget", /* tp_name */
222 sizeof(snackWidget), /* tp_size */
223 0, /* tp_itemsize */
1dfa0cfa 224 widgetDestructor, /* tp_dealloc */
80d03bd8 225 0, /* tp_print */
226 widgetGetAttr, /* tp_getattr */
227 0, /* tp_setattr */
228 0, /* tp_compare */
229 0, /* tp_repr */
230 0, /* tp_as_number */
231 0, /* tp_as_sequence */
232 0, /* tp_as_mapping */
233};
234
1dfa0cfa 235static snackWidget * snackWidgetNew (void) {
236 snackWidget * widget;
237
238 widget = PyObject_NEW(snackWidget, &snackWidgetType);
239
240 widget->scs.cb = NULL;
241 widget->scs.data = NULL;
242
243 return widget;
244}
245
80d03bd8 246static PyObject * initScreen(PyObject * s, PyObject * args) {
1dfa0cfa 247 suspend.cb = NULL;
248 suspend.data = NULL;
249
80d03bd8 250 newtInit();
251 newtCls();
252
253 Py_INCREF(Py_None);
254 return Py_None;
255}
256
257static PyObject * finishScreen(PyObject * s, PyObject * args) {
dd66cfb7 258 Py_XDECREF (suspend.cb);
259 Py_XDECREF (suspend.data);
260
80d03bd8 261 newtFinished();
262 Py_INCREF(Py_None);
263 return Py_None;
264}
265
266static PyObject * refreshScreen(PyObject * s, PyObject * args) {
267 newtRefresh();
268 Py_INCREF(Py_None);
269 return Py_None;
270}
271
06cf519e 272static PyObject * scaleWidget(PyObject * s, PyObject * args) {
273 snackWidget * widget;
274 int width, fullAmount;
275
276 if (!PyArg_ParseTuple(args, "ii", &width, &fullAmount)) return NULL;
277
1dfa0cfa 278 widget = snackWidgetNew ();
06cf519e 279 widget->co = newtScale(-1, -1, width, fullAmount);
280
281 return (PyObject *) widget;
282}
283
284static PyObject * scaleSet(snackWidget * s, PyObject * args) {
285 int amount;
286
287 if (!PyArg_ParseTuple(args, "i", &amount)) return NULL;
288
289 newtScaleSet(s->co, amount);
290
291 Py_INCREF(Py_None);
292 return Py_None;
293}
294
9f0ab2ac 295static PyObject * screenSize(PyObject * s, PyObject * args) {
296 int width, height;
297
298 if (!PyArg_ParseTuple(args, ""))
299 return NULL;
300
301 newtGetScreenSize(&width, &height);
302
303 return Py_BuildValue("(ii)", width, height);
304}
305
5d678658 306static void suspendCallbackMarshall(void * data) {
307 struct callbackStruct * scs = data;
308 PyObject * args, * result;
309
1dfa0cfa 310 if (scs->data) {
311 args = Py_BuildValue("(O)", scs->data);
312 result = PyEval_CallObject(scs->cb, args);
313 Py_DECREF (args);
314 } else
315 result = PyEval_CallObject(scs->cb, NULL);
316
317 if (!result) {
318 PyErr_Print();
319 PyErr_Clear();
320 }
5d678658 321
5d678658 322 Py_XDECREF(result);
323
324 return;
325}
326
327static void callbackMarshall(newtComponent co, void * data) {
328 struct callbackStruct * scs = data;
06cf519e 329 PyObject * args, * result;
330
1dfa0cfa 331 if (scs->data) {
332 args = Py_BuildValue("(O)", scs->data);
333 result = PyEval_CallObject(scs->cb, args);
334 Py_DECREF (args);
335 } else
336 result = PyEval_CallObject(scs->cb, NULL);
1ea8f607 337
5d678658 338 if (!result) {
339 PyErr_Print();
340 PyErr_Clear();
341 }
342
1ea8f607 343 Py_XDECREF(result);
06cf519e 344
1ea8f607 345 return;
06cf519e 346}
347
348static PyObject * setSuspendCallback(PyObject * s, PyObject * args) {
1dfa0cfa 349 if (!PyArg_ParseTuple(args, "O|O", &suspend.cb, &suspend.data))
06cf519e 350 return NULL;
351
1dfa0cfa 352 Py_INCREF (suspend.cb);
353 Py_XINCREF (suspend.data);
354
355 newtSetSuspendCallback(suspendCallbackMarshall, &suspend);
06cf519e 356
357 Py_INCREF(Py_None);
358 return Py_None;
359}
360
75fb0452 361static PyObject * drawRootText(PyObject * s, PyObject * args) {
362 int left, top;
363 char * text;
364
365 if (!PyArg_ParseTuple(args, "iis", &left, &top, &text))
366 return NULL;
367
ec65dcfe 368 newtDrawRootText(left, top, text);
75fb0452 369
370 Py_INCREF(Py_None);
371 return Py_None;
372}
373
f1aef30b 374static PyObject * doSuspend(PyObject * s, PyObject * args) {
375 newtSuspend();
376
377 Py_INCREF(Py_None);
378 return Py_None;
379}
380
381static PyObject * doResume(PyObject * s, PyObject * args) {
382 newtResume();
383
384 Py_INCREF(Py_None);
385 return Py_None;
386}
387
75fb0452 388static PyObject * popHelpLine(PyObject * s, PyObject * args) {
389 newtPopHelpLine();
390 Py_INCREF(Py_None);
391 return Py_None;
392}
393
394static PyObject * pushHelpLine(PyObject * s, PyObject * args) {
395 char * text;
396
397 if (!PyArg_ParseTuple(args, "s", &text))
398 return NULL;
399
400 if (!strcmp(text, "*default*"))
401 newtPushHelpLine(NULL);
402 else
403 newtPushHelpLine(text);
404
405 Py_INCREF(Py_None);
406 return Py_None;
407}
408
6e25d997 409static PyObject * reflowText(PyObject * s, PyObject * args) {
410 char * text, * new;
411 int width, minus = 5, plus = 5;
412 int realWidth, realHeight;
413 PyObject * tuple;
414
415 if (!PyArg_ParseTuple(args, "si|ii", &text, &width, &minus, &plus))
416 return NULL;
417
418 new = newtReflowText(text, width, minus, plus, &realWidth, &realHeight);
419
420 tuple = Py_BuildValue("(sii)", new, realWidth, realHeight);
421 free(new);
422
423 return tuple;
424}
425
80d03bd8 426static PyObject * centeredWindow(PyObject * s, PyObject * args) {
427 int width, height;
428 char * title;
429
430 if (!PyArg_ParseTuple(args, "iis", &width, &height, &title))
431 return NULL;
432
433 newtCenteredWindow(width, height, title);
434
435 Py_INCREF(Py_None);
436 return Py_None;
437}
438
439static PyObject * gridWrappedWindow(PyObject * s, PyObject * args) {
440 snackGrid * grid;
441 char * title;
2b6641b1 442 int x = -1, y = -1;
80d03bd8 443
2b6641b1 444 if (!PyArg_ParseTuple(args, "O!s|ii", &snackGridType, &grid, &title,
445 &x, &y))
80d03bd8 446 return NULL;
447
2b6641b1 448 if (y == -1)
449 newtGridWrappedWindow(grid->grid, title);
450 else
451 newtGridWrappedWindowAt(grid->grid, title, x, y);
80d03bd8 452
453 Py_INCREF(Py_None);
454 return Py_None;
455}
456
457static PyObject * openWindow(PyObject * s, PyObject * args) {
458 int left, top, width, height;
459 char * title;
460
461 if (!PyArg_ParseTuple(args, "iiiis", &left, &top, &width, &height, &title))
462 return NULL;
463
464 newtOpenWindow(left, top, width, height, title);
465
466 Py_INCREF(Py_None);
467 return Py_None;
468}
469
470static PyObject * popWindow(PyObject * s, PyObject * args) {
471 newtPopWindow();
472 Py_INCREF(Py_None);
473 return Py_None;
474}
475
476static PyObject * messageWindow(PyObject * s, PyObject * args) {
477 char * title, * text;
478 char * okbutton = "Ok";
479
480 if (!PyArg_ParseTuple(args, "ss|s", &title, &text, &okbutton))
481 return NULL;
482
483 newtWinMessage(title, okbutton, text);
484
485 Py_INCREF(Py_None);
486 return Py_None;
487}
488
489static PyObject * choiceWindow(PyObject * s, PyObject * args) {
490 char * title, * text;
491 char * okbutton = "Ok";
492 char * cancelbutton = "Cancel";
493 int rc;
494
495 if (!PyArg_ParseTuple(args, "ss|ss", &title, &text, &okbutton,
496 &cancelbutton))
497 return NULL;
498
499 rc = newtWinChoice(title, okbutton, cancelbutton, text);
500
93a3a267 501 return Py_BuildValue("i", rc);
80d03bd8 502}
503
504static PyObject * ternaryWindow(PyObject * s, PyObject * args) {
505 char * title, * text, * button1, * button2, * button3;
506 int rc;
507
508 if (!PyArg_ParseTuple(args, "sssss", &title, &text, &button1, &button2,
509 &button3))
510 return NULL;
511
512 rc = newtWinTernary(title, button1, button2, button3, text);
513
514 return Py_BuildValue("i", rc);
515}
516
517static snackWidget * buttonWidget(PyObject * s, PyObject * args) {
518 snackWidget * widget;
519 char * label;
520
521 if (!PyArg_ParseTuple(args, "s", &label)) return NULL;
522
1dfa0cfa 523 widget = snackWidgetNew ();
80d03bd8 524 widget->co = newtButton(-1, -1, label);
525
526 return widget;
527}
528
529static snackWidget * labelWidget(PyObject * s, PyObject * args) {
530 char * label;
531 snackWidget * widget;
532
533 if (!PyArg_ParseTuple(args, "s", &label)) return NULL;
534
1dfa0cfa 535 widget = snackWidgetNew ();
80d03bd8 536 widget->co = newtLabel(-1, -1, label);
537
538 return widget;
539}
540
522d3500 541static PyObject * widgetLabelText(snackWidget * s, PyObject * args) {
542 char * label;
543
544 if (!PyArg_ParseTuple(args, "s", &label)) return NULL;
545
546 newtLabelSetText(s->co, label);
547
548 Py_INCREF(Py_None);
549 return Py_None;
550}
551
36f926a6 552static PyObject * widgetTextboxText(snackWidget * s, PyObject * args) {
553 char * text;
554
555 if (!PyArg_ParseTuple(args, "s", &text)) return NULL;
556
557 newtTextboxSetText(s->co, text);
558
559 Py_INCREF(Py_None);
560 return Py_None;
561}
562
6e25d997 563static snackWidget * listboxWidget(PyObject * s, PyObject * args) {
564 snackWidget * widget;
565 int height;
566 int doScroll = 0, returnExit = 0 ;
567
568 if (!PyArg_ParseTuple(args, "i|ii", &height, &doScroll, &returnExit))
569 return NULL;
570
1dfa0cfa 571 widget = snackWidgetNew ();
6e25d997 572 widget->co = newtListbox(-1, -1, height,
49a91bd2 573 (doScroll ? NEWT_FLAG_SCROLL : 0) |
6e25d997 574 (returnExit ? NEWT_FLAG_RETURNEXIT : 0));
a507b3ec 575 widget->anint = 1;
6e25d997 576
577 return widget;
578}
579
580static snackWidget * textWidget(PyObject * s, PyObject * args) {
581 char * text;
582 int width, height;
583 int scrollBar = 0;
36f926a6 584 int wrap = 0;
6e25d997 585 snackWidget * widget;
586
36f926a6 587 if (!PyArg_ParseTuple(args, "iis|ii", &width, &height, &text, &scrollBar, &wrap))
6e25d997 588 return NULL;
589
1dfa0cfa 590 widget = snackWidgetNew ();
6e25d997 591 widget->co = newtTextbox(-1, -1, width, height,
36f926a6 592 (scrollBar ? NEWT_FLAG_SCROLL : 0) |
593 (wrap ? NEWT_FLAG_WRAP : 0));
6e25d997 594 newtTextboxSetText(widget->co, text);
595
596 return widget;
597}
598
80d03bd8 599static snackWidget * radioButtonWidget(PyObject * s, PyObject * args) {
600 snackWidget * widget, * group;
601 char * text;
602 int isOn;
603
604 if (!PyArg_ParseTuple(args, "sOi", &text, &group, &isOn))
605 return NULL;
606
1dfa0cfa 607 widget = snackWidgetNew ();
80d03bd8 608
609 if ((PyObject *) group == Py_None)
610 widget->co = newtRadiobutton(-1, -1, text, isOn, NULL);
611 else
612 widget->co = newtRadiobutton(-1, -1, text, isOn, group->co);
613
614 return widget;
615}
616
617static snackWidget * checkboxWidget(PyObject * s, PyObject * args) {
618 snackWidget * widget;
619 char * text;
620 int isOn;
621
622 if (!PyArg_ParseTuple(args, "si", &text, &isOn)) return NULL;
623
1dfa0cfa 624 widget = snackWidgetNew ();
80d03bd8 625 widget->co = newtCheckbox(-1, -1, text, isOn ? '*' : ' ', NULL,
626 &widget->achar);
627
628 return widget;
629}
630
c573c71b 631static PyObject * widgetCheckboxSetFlags(snackWidget * s, PyObject * args) {
632 int flag, sense;
633
634 if (!PyArg_ParseTuple(args, "ii", &flag, &sense)) return NULL;
635
636 newtCheckboxSetFlags(s->co, flag, sense);
637
638 Py_INCREF(Py_None);
639 return Py_None;
640}
641
642
80d03bd8 643static snackWidget * entryWidget(PyObject * s, PyObject * args) {
644 snackWidget * widget;
645 int width;
646 char * initial;
5a8da880 647 int isHidden, isScrolled, returnExit;
80d03bd8 648
b85af896 649 if (!PyArg_ParseTuple(args, "isiii", &width, &initial,
5a8da880 650 &isHidden, &isScrolled, &returnExit)) return NULL;
80d03bd8 651
1dfa0cfa 652 widget = snackWidgetNew ();
80d03bd8 653 widget->co = newtEntry(-1, -1, initial, width, (char **) &widget->apointer,
654 (isHidden ? NEWT_FLAG_HIDDEN : 0) |
5a8da880 655 (returnExit ? NEWT_FLAG_RETURNEXIT : 0) |
49a91bd2 656 (isScrolled ? NEWT_FLAG_SCROLL : 0));
80d03bd8 657
658 return widget;
659}
660
661static snackForm * formCreate(PyObject * s, PyObject * args) {
662 snackForm * form;
663
664 form = PyObject_NEW(snackForm, &snackFormType);
665 form->fo = newtForm(NULL, NULL, 0);
666
667 return form;
668}
669
670static snackGrid * gridCreate(PyObject * s, PyObject * args) {
671 int rows, cols;
672 snackGrid * grid;
673
674 if (!PyArg_ParseTuple(args, "ii", &cols, &rows)) return NULL;
675
676 grid = PyObject_NEW(snackGrid, &snackGridType);
677 grid->grid = newtCreateGrid(cols, rows);
678
679 return grid;
680}
681
682static PyObject * gridGetAttr(PyObject * s, char * name) {
683 return Py_FindMethod(gridMethods, s, name);
684}
685
686static PyObject * gridPlace(snackGrid * grid, PyObject * args) {
687 int x, y;
688
689 if (!PyArg_ParseTuple(args, "ii", &x, &y)) return NULL;
690
691 newtGridPlace(grid->grid, x, y);
692
693 Py_INCREF(Py_None);
694 return Py_None;
695}
696
697static PyObject * gridSetField(snackGrid * grid, PyObject * args) {
698 snackWidget * w;
6e25d997 699 snackGrid * g;
80d03bd8 700 int x, y;
701 int pLeft = 0, pTop = 0, pRight = 0, pBottom = 0;
6e25d997 702 int anchorFlags = 0, growFlags = 0;
80d03bd8 703
6e25d997 704 if (!PyArg_ParseTuple(args, "iiO|(iiii)ii", &x, &y,
705 &w, &pLeft, &pTop, &pRight, &pBottom,
706 &anchorFlags, &growFlags))
80d03bd8 707 return NULL;
708
6e25d997 709 if (w->ob_type == &snackWidgetType) {
710 newtGridSetField(grid->grid, x, y, NEWT_GRID_COMPONENT,
711 w->co, pLeft, pTop, pRight, pBottom, anchorFlags,
712 growFlags);
713 } else {
714 g = (snackGrid *) w;
715 newtGridSetField(grid->grid, x, y, NEWT_GRID_SUBGRID,
716 g->grid, pLeft, pTop, pRight, pBottom, anchorFlags,
717 growFlags);
718 }
80d03bd8 719
720 Py_INCREF(Py_None);
721 return Py_None;
722}
723
724static PyObject * formGetAttr(PyObject * s, char * name) {
725 return Py_FindMethod(formMethods, s, name);
726}
727
bd38d47e 728static PyObject * formDraw(snackForm * s, PyObject * args) {
729 newtDrawForm(s->fo);
730
731 Py_INCREF(Py_None);
732 return Py_None;
733}
734
80d03bd8 735static PyObject * formAdd(snackForm * s, PyObject * args) {
736 snackWidget * w;
737 int size = PyTuple_Size(args), i;
738
739 if (!size) {
740 /* this is a hack, I should give an error directly */
741 if (!PyArg_ParseTuple(args, "O!", &snackWidgetType, &w))
742 return NULL;
743 }
744
745 for (i = 0; i < size; i++) {
746 w = (snackWidget *) PyTuple_GET_ITEM(args, i);
747 newtFormAddComponent(s->fo, w->co);
748 }
749
750 Py_INCREF(Py_None);
751 return Py_None;
752}
753
754static PyObject * formRun(snackForm * s, PyObject * args) {
ea59ae12 755 struct newtExitStruct result;
756
757 newtFormRun(s->fo, &result);
758
759 if (result.reason == NEWT_EXIT_HOTKEY)
760 return Py_BuildValue("(si)", "hotkey", result.u.key);
73390860 761 else if (result.reason == NEWT_EXIT_TIMER)
762 return Py_BuildValue("(si)", "timer", 0);
ea59ae12 763 else
764 return Py_BuildValue("(si)", "widget", result.u.co);
765}
766
767static PyObject * formHotKey(snackForm * s, PyObject * args) {
768 int key;
769
770 if (!PyArg_ParseTuple(args, "i", &key))
771 return NULL;
772
773 newtFormAddHotKey(s->fo, key);
80d03bd8 774
775 Py_INCREF(Py_None);
776 return Py_None;
777}
778
73390860 779static PyObject * formSetTimer(snackForm * form, PyObject * args) {
780 int millisecs;
781
782 if (!PyArg_ParseTuple(args, "i", &millisecs))
783 return NULL;
784
785 newtFormSetTimer(form->fo, millisecs);
786
787 Py_INCREF(Py_None);
788 return Py_None;
789}
790
5d678658 791static PyObject * formSetCurrent(snackForm * form, PyObject * args) {
792 snackWidget * w;
793
794 if (!PyArg_ParseTuple(args, "O", &w))
795 return NULL;
796
797 newtFormSetCurrent(form->fo, w->co);
798
799 Py_INCREF(Py_None);
800 return Py_None;
801}
802
80d03bd8 803static PyObject * widgetGetAttr(PyObject * s, char * name) {
804 snackWidget * w = (snackWidget *) s;
805
ea59ae12 806 if (!strcmp(name, "key")) {
80d03bd8 807 return Py_BuildValue("i", w->co);
808 } else if (!strcmp(name, "entryValue")) {
809 return Py_BuildValue("s", w->apointer);
810 } else if (!strcmp(name, "checkboxValue")) {
811 return Py_BuildValue("i", w->achar == ' ' ? 0 : 1);
812 } else if (!strcmp(name, "radioValue")) {
813 return Py_BuildValue("i", newtRadioGetCurrent(w->co));
814 }
815
816 return Py_FindMethod(widgetMethods, s, name);
817}
818
1dfa0cfa 819static void widgetDestructor(PyObject * o) {
820 snackWidget * s = (snackWidget *) o;
821
822 Py_XDECREF (s->scs.cb);
823 Py_XDECREF (s->scs.data);
824
825 PyMem_DEL(o);
826}
827
6a703ca8 828static PyObject * widgetAddCallback(snackWidget * s, PyObject * args) {
1dfa0cfa 829 s->scs.cb = NULL;
830 s->scs.data = NULL;
831
5d678658 832 if (!PyArg_ParseTuple(args, "O|O", &s->scs.cb, &s->scs.data))
6a703ca8 833 return NULL;
834
1dfa0cfa 835 Py_INCREF (s->scs.cb);
836 Py_XINCREF (s->scs.data);
837
5d678658 838 newtComponentAddCallback(s->co, callbackMarshall, &s->scs);
6a703ca8 839
840 Py_INCREF(Py_None);
841 return Py_None;
842}
843
80d03bd8 844static PyObject * widgetEntrySetValue(snackWidget * s, PyObject * args) {
845 char * val;
846
847 if (!PyArg_ParseTuple(args, "s", &val))
848 return NULL;
849
850 newtEntrySet(s->co, val, 1);
851
852 Py_INCREF(Py_None);
853 return Py_None;
854}
855
5d678658 856static PyObject * widgetEntrySetFlags(snackWidget * s, PyObject * args) {
857 int flag, sense;
858
859 if (!PyArg_ParseTuple(args, "ii", &flag, &sense)) return NULL;
860
861 newtEntrySetFlags(s->co, flag, sense);
862
863 Py_INCREF(Py_None);
864 return Py_None;
865}
866
867
6e25d997 868static PyObject * widgetListboxAdd(snackWidget * s, PyObject * args) {
869 char * text;
870
871 if (!PyArg_ParseTuple(args, "s", &text))
872 return NULL;
873
874 newtListboxAddEntry(s->co, text, (void *) s->anint);
875
876 return PyInt_FromLong(s->anint++);
877}
878
a507b3ec 879static PyObject * widgetListboxIns(snackWidget * s, PyObject * args) {
880 char * text;
881 int key;
882
883 if (!PyArg_ParseTuple(args, "si", &text, &key))
884 return NULL;
885
886 newtListboxInsertEntry(s->co, text, (void *) s->anint, (void *) key);
887
888 return PyInt_FromLong(s->anint++);
889}
890
891static PyObject * widgetListboxDel(snackWidget * s, PyObject * args) {
892 int key;
893
894 if (!PyArg_ParseTuple(args, "i", &key))
895 return NULL;
896
897 newtListboxDeleteEntry(s->co, (void *) key);
898
899 Py_INCREF(Py_None);
900 return Py_None;
901}
902
6e25d997 903static PyObject * widgetListboxGet(snackWidget * s, PyObject * args) {
904 if (!PyArg_ParseTuple(args, ""))
905 return NULL;
906
907 return PyInt_FromLong((long) newtListboxGetCurrent(s->co));
908}
909
99438c19 910static PyObject * widgetListboxSet(snackWidget * s, PyObject * args) {
911 int index;
912
913 if (!PyArg_ParseTuple(args, "i", &index))
914 return NULL;
915
f5ec4033 916 newtListboxSetCurrentByKey(s->co, index);
99438c19 917
918 Py_INCREF(Py_None);
919 return Py_None;
920}
921
6e25d997 922static PyObject * widgetListboxSetW(snackWidget * s, PyObject * args) {
923 int width;
924
925 if (!PyArg_ParseTuple(args, "i", &width))
926 return NULL;
927
928 newtListboxSetWidth(s->co, width);
929
930 Py_INCREF(Py_None);
931 return Py_None;
932}
933
80d03bd8 934static void emptyDestructor(PyObject * s) {
935}
936
f06c5a99 937static snackWidget * checkboxTreeWidget(PyObject * s, PyObject * args) {
938 int height;
939 int scrollBar = 0;
940 snackWidget * widget;
941
942 if (!PyArg_ParseTuple(args, "i|i", &height, &scrollBar))
943 return NULL;
944
1dfa0cfa 945 widget = snackWidgetNew ();
f06c5a99 946 widget->co = newtCheckboxTree(-1, -1, height,
947 scrollBar ? NEWT_FLAG_SCROLL : 0);
948
949 widget->anint = 1;
950
951 return widget;
952}
953
75d40644 954static PyObject * widgetCheckboxTreeAddItem(snackWidget * s, PyObject * args) {
f06c5a99 955 char * text;
f06c5a99 956 int selected = 0;
75d40644 957 PyObject * pathList, * o;
958 int len;
959 int * path;
960 int i;
961
962 if (!PyArg_ParseTuple(args, "sOi", &text, &pathList, &selected))
f06c5a99 963 return NULL;
964
75d40644 965 len = PyTuple_Size(pathList);
966 path = alloca(sizeof(*path) * (len + 1));
967 for (i = 0; i < len; i++) {
968 o = PyTuple_GetItem(pathList, i);
969 path[i] = PyInt_AsLong(o);
75d40644 970 }
971 path[len] = NEWT_ARG_LAST;
972
5a6729cf 973 newtCheckboxTreeAddArray(s->co, text, (void *) s->anint,
75d40644 974 selected ? NEWT_FLAG_SELECTED : 0, path);
f06c5a99 975
976 return PyInt_FromLong(s->anint++);
977}
978
2b6641b1 979static PyObject * widgetCheckboxTreeGetCur(snackWidget * s, PyObject * args) {
980 if (!PyArg_ParseTuple(args, ""))
981 return NULL;
982
983 return PyInt_FromLong((int) newtCheckboxTreeGetCurrent(s->co));
984}
985
c895490d 986static PyObject * widgetCheckboxTreeSetEntry(snackWidget * s, PyObject * args) {
987 int data;
988 char *text;
989
990 if (!PyArg_ParseTuple(args, "is", &data, &text)) return NULL;
991
992 newtCheckboxTreeSetEntry(s->co, (void *)data, text);
993
994 Py_INCREF(Py_None);
995 return Py_None;
996}
997
998static PyObject * widgetCheckboxTreeSetEntryValue(snackWidget * s, PyObject * args) {
999 int data;
1000 int isOn = 1;
1001
1002 if (!PyArg_ParseTuple(args, "i|i", &data, &isOn)) return NULL;
1003
1004 newtCheckboxTreeSetEntryValue(s->co, (void *)data,
1005 isOn ? NEWT_CHECKBOXTREE_SELECTED :
1006 NEWT_CHECKBOXTREE_UNSELECTED);
1007
1008 Py_INCREF(Py_None);
1009 return Py_None;
1010}
1011
1012static PyObject * widgetCheckboxTreeGetEntryValue(snackWidget * s, PyObject * args) {
1013 int data;
1014 int isOn = 0;
1015 int isBranch = 0;
1016 char selection;
1017
1018 if (!PyArg_ParseTuple(args, "i", &data)) return NULL;
1019
1020 selection = newtCheckboxTreeGetEntryValue(s->co, (void *)data);
1021
1022 if (selection == -1) return NULL;
1023
1024 switch (selection) {
1025 case NEWT_CHECKBOXTREE_EXPANDED:
1026 isOn = 1;
1027 case NEWT_CHECKBOXTREE_COLLAPSED:
1028 isBranch = 1;
1029 break;
1030 case NEWT_CHECKBOXTREE_UNSELECTED:
1031 break;
1032 default:
1033 isOn = 1;
1034 break;
1035 }
1036 return Py_BuildValue("(ii)", isBranch, isOn);
1037}
1038
5a6729cf 1039static PyObject * widgetCheckboxTreeGetSel(snackWidget * s,
f06c5a99 1040 PyObject * args) {
1041 void ** selection;
1042 int numselected;
5a6729cf 1043 int i;
1044 PyObject * sel;
f06c5a99 1045
2b6641b1 1046 if (!PyArg_ParseTuple(args, ""))
1047 return NULL;
1048
f06c5a99 1049 selection = newtCheckboxTreeGetSelection(s->co, &numselected);
1050
788ec656 1051 sel = PyList_New(0);
1052
5a6729cf 1053 if (!selection) {
788ec656 1054 return sel;
f06c5a99 1055 }
1056
5a6729cf 1057 sel = PyList_New(0);
1058 for (i = 0; i < numselected; i++) {
1059 PyList_Append(sel, PyInt_FromLong((int) selection[i]));
5a6729cf 1060 }
1061 free(selection);
f06c5a99 1062
5a6729cf 1063 return sel;
f06c5a99 1064}
1065
80d03bd8 1066void init_snack(void) {
6e25d997 1067 PyObject * d, * m;
1068
1069 m = Py_InitModule("_snack", snackModuleMethods);
1070 d = PyModule_GetDict(m);
1071
1072 PyDict_SetItemString(d, "ANCHOR_LEFT", PyInt_FromLong(NEWT_ANCHOR_LEFT));
1073 PyDict_SetItemString(d, "ANCHOR_TOP", PyInt_FromLong(NEWT_ANCHOR_TOP));
1074 PyDict_SetItemString(d, "ANCHOR_RIGHT", PyInt_FromLong(NEWT_ANCHOR_RIGHT));
1075 PyDict_SetItemString(d, "ANCHOR_BOTTOM",
1076 PyInt_FromLong(NEWT_ANCHOR_BOTTOM));
1077 PyDict_SetItemString(d, "GRID_GROWX", PyInt_FromLong(NEWT_GRID_FLAG_GROWX));
1078 PyDict_SetItemString(d, "GRID_GROWY", PyInt_FromLong(NEWT_GRID_FLAG_GROWY));
ea59ae12 1079
1080 PyDict_SetItemString(d, "FORM_EXIT_HOTKEY", PyString_FromString("hotkey"));
1081 PyDict_SetItemString(d, "FORM_EXIT_WIDGET", PyString_FromString("widget"));
73390860 1082 PyDict_SetItemString(d, "FORM_EXIT_TIMER", PyString_FromString("timer"));
ea59ae12 1083
1084 PyDict_SetItemString(d, "KEY_F1", PyInt_FromLong(NEWT_KEY_F1));
1085 PyDict_SetItemString(d, "KEY_F2", PyInt_FromLong(NEWT_KEY_F2));
1086 PyDict_SetItemString(d, "KEY_F3", PyInt_FromLong(NEWT_KEY_F3));
1087 PyDict_SetItemString(d, "KEY_F4", PyInt_FromLong(NEWT_KEY_F4));
1088 PyDict_SetItemString(d, "KEY_F5", PyInt_FromLong(NEWT_KEY_F5));
1089 PyDict_SetItemString(d, "KEY_F6", PyInt_FromLong(NEWT_KEY_F6));
1090 PyDict_SetItemString(d, "KEY_F7", PyInt_FromLong(NEWT_KEY_F7));
1091 PyDict_SetItemString(d, "KEY_F8", PyInt_FromLong(NEWT_KEY_F8));
1092 PyDict_SetItemString(d, "KEY_F9", PyInt_FromLong(NEWT_KEY_F9));
1093 PyDict_SetItemString(d, "KEY_F10", PyInt_FromLong(NEWT_KEY_F10));
1094 PyDict_SetItemString(d, "KEY_F11", PyInt_FromLong(NEWT_KEY_F11));
1095 PyDict_SetItemString(d, "KEY_F12", PyInt_FromLong(NEWT_KEY_F12));
5d678658 1096
1097 PyDict_SetItemString(d, "FLAG_DISABLED", PyInt_FromLong(NEWT_FLAG_DISABLED));
1098 PyDict_SetItemString(d, "FLAGS_SET", PyInt_FromLong(NEWT_FLAGS_SET));
1099 PyDict_SetItemString(d, "FLAGS_RESET", PyInt_FromLong(NEWT_FLAGS_RESET));
1100 PyDict_SetItemString(d, "FLAGS_TOGGLE", PyInt_FromLong(NEWT_FLAGS_TOGGLE));
80d03bd8 1101}
Mirror of https://pagure.io/newt.git