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