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