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