source: vendor/python/2.5/Modules/_curses_panel.c@ 3397

Last change on this file since 3397 was 3225, checked in by bird, 19 years ago

Python 2.5
File size: 12.3 KB
Line 
1/*
2 * Interface to the ncurses panel library
3 *
4 * Original version by Thomas Gellekum
5 */
6
7/* Release Number */
8
9static char *PyCursesVersion = "2.1";
10
11/* Includes */
12
13#include "Python.h"
14
15#include "py_curses.h"
16
17#include <panel.h>
18
19static PyObject *PyCursesError;
20
21
22/* Utility Functions */
23
24/*
25 * Check the return code from a curses function and return None
26 * or raise an exception as appropriate.
27 */
28
29static PyObject *
30PyCursesCheckERR(int code, char *fname)
31{
32 if (code != ERR) {
33 Py_INCREF(Py_None);
34 return Py_None;
35 } else {
36 if (fname == NULL) {
37 PyErr_SetString(PyCursesError, catchall_ERR);
38 } else {
39 PyErr_Format(PyCursesError, "%s() returned ERR", fname);
40 }
41 return NULL;
42 }
43}
44
45/*****************************************************************************
46 The Panel Object
47******************************************************************************/
48
49/* Definition of the panel object and panel type */
50
51typedef struct {
52 PyObject_HEAD
53 PANEL *pan;
54 PyCursesWindowObject *wo; /* for reference counts */
55} PyCursesPanelObject;
56
57PyTypeObject PyCursesPanel_Type;
58
59#define PyCursesPanel_Check(v) ((v)->ob_type == &PyCursesPanel_Type)
60
61/* Some helper functions. The problem is that there's always a window
62 associated with a panel. To ensure that Python's GC doesn't pull
63 this window from under our feet we need to keep track of references
64 to the corresponding window object within Python. We can't use
65 dupwin(oldwin) to keep a copy of the curses WINDOW because the
66 contents of oldwin is copied only once; code like
67
68 win = newwin(...)
69 pan = win.panel()
70 win.addstr(some_string)
71 pan.window().addstr(other_string)
72
73 will fail. */
74
75/* We keep a linked list of PyCursesPanelObjects, lop. A list should
76 suffice, I don't expect more than a handful or at most a few
77 dozens of panel objects within a typical program. */
78typedef struct _list_of_panels {
79 PyCursesPanelObject *po;
80 struct _list_of_panels *next;
81} list_of_panels;
82
83/* list anchor */
84static list_of_panels *lop;
85
86/* Insert a new panel object into lop */
87static int
88insert_lop(PyCursesPanelObject *po)
89{
90 list_of_panels *new;
91
92 if ((new = (list_of_panels *)malloc(sizeof(list_of_panels))) == NULL) {
93 PyErr_NoMemory();
94 return -1;
95 }
96 new->po = po;
97 new->next = lop;
98 lop = new;
99 return 0;
100}
101
102/* Remove the panel object from lop */
103static void
104remove_lop(PyCursesPanelObject *po)
105{
106 list_of_panels *temp, *n;
107
108 temp = lop;
109 if (temp->po == po) {
110 lop = temp->next;
111 free(temp);
112 return;
113 }
114 while (temp->next == NULL || temp->next->po != po) {
115 if (temp->next == NULL) {
116 PyErr_SetString(PyExc_RuntimeError,
117 "remove_lop: can't find Panel Object");
118 return;
119 }
120 temp = temp->next;
121 }
122 n = temp->next->next;
123 free(temp->next);
124 temp->next = n;
125 return;
126}
127
128/* Return the panel object that corresponds to pan */
129static PyCursesPanelObject *
130find_po(PANEL *pan)
131{
132 list_of_panels *temp;
133 for (temp = lop; temp->po->pan != pan; temp = temp->next)
134 if (temp->next == NULL) return NULL; /* not found!? */
135 return temp->po;
136}
137
138/* Function Prototype Macros - They are ugly but very, very useful. ;-)
139
140 X - function name
141 TYPE - parameter Type
142 ERGSTR - format string for construction of the return value
143 PARSESTR - format string for argument parsing */
144
145#define Panel_NoArgNoReturnFunction(X) \
146static PyObject *PyCursesPanel_##X(PyCursesPanelObject *self) \
147{ return PyCursesCheckERR(X(self->pan), # X); }
148
149#define Panel_NoArgTrueFalseFunction(X) \
150static PyObject *PyCursesPanel_##X(PyCursesPanelObject *self) \
151{ \
152 if (X (self->pan) == FALSE) { Py_INCREF(Py_False); return Py_False; } \
153 else { Py_INCREF(Py_True); return Py_True; } }
154
155#define Panel_TwoArgNoReturnFunction(X, TYPE, PARSESTR) \
156static PyObject *PyCursesPanel_##X(PyCursesPanelObject *self, PyObject *args) \
157{ \
158 TYPE arg1, arg2; \
159 if (!PyArg_ParseTuple(args, PARSESTR, &arg1, &arg2)) return NULL; \
160 return PyCursesCheckERR(X(self->pan, arg1, arg2), # X); }
161
162/* ------------- PANEL routines --------------- */
163
164Panel_NoArgNoReturnFunction(bottom_panel)
165Panel_NoArgNoReturnFunction(hide_panel)
166Panel_NoArgNoReturnFunction(show_panel)
167Panel_NoArgNoReturnFunction(top_panel)
168Panel_NoArgTrueFalseFunction(panel_hidden)
169Panel_TwoArgNoReturnFunction(move_panel, int, "ii;y,x")
170
171/* Allocation and deallocation of Panel Objects */
172
173static PyObject *
174PyCursesPanel_New(PANEL *pan, PyCursesWindowObject *wo)
175{
176 PyCursesPanelObject *po;
177
178 po = PyObject_NEW(PyCursesPanelObject, &PyCursesPanel_Type);
179 if (po == NULL) return NULL;
180 po->pan = pan;
181 po->wo = wo;
182 Py_INCREF(wo);
183 if (insert_lop(po) < 0) {
184 PyObject_DEL(po);
185 return NULL;
186 }
187 return (PyObject *)po;
188}
189
190static void
191PyCursesPanel_Dealloc(PyCursesPanelObject *po)
192{
193 (void)del_panel(po->pan);
194 Py_DECREF(po->wo);
195 remove_lop(po);
196 PyObject_DEL(po);
197}
198
199/* panel_above(NULL) returns the bottom panel in the stack. To get
200 this behaviour we use curses.panel.bottom_panel(). */
201static PyObject *
202PyCursesPanel_above(PyCursesPanelObject *self)
203{
204 PANEL *pan;
205 PyCursesPanelObject *po;
206
207 pan = panel_above(self->pan);
208
209 if (pan == NULL) { /* valid output, it means the calling panel
210 is on top of the stack */
211 Py_INCREF(Py_None);
212 return Py_None;
213 }
214 po = find_po(pan);
215 if (po == NULL) {
216 PyErr_SetString(PyExc_RuntimeError,
217 "panel_above: can't find Panel Object");
218 return NULL;
219 }
220 Py_INCREF(po);
221 return (PyObject *)po;
222}
223
224/* panel_below(NULL) returns the top panel in the stack. To get
225 this behaviour we use curses.panel.top_panel(). */
226static PyObject *
227PyCursesPanel_below(PyCursesPanelObject *self)
228{
229 PANEL *pan;
230 PyCursesPanelObject *po;
231
232 pan = panel_below(self->pan);
233
234 if (pan == NULL) { /* valid output, it means the calling panel
235 is on the bottom of the stack */
236 Py_INCREF(Py_None);
237 return Py_None;
238 }
239 po = find_po(pan);
240 if (po == NULL) {
241 PyErr_SetString(PyExc_RuntimeError,
242 "panel_below: can't find Panel Object");
243 return NULL;
244 }
245 Py_INCREF(po);
246 return (PyObject *)po;
247}
248
249static PyObject *
250PyCursesPanel_window(PyCursesPanelObject *self)
251{
252 Py_INCREF(self->wo);
253 return (PyObject *)self->wo;
254}
255
256static PyObject *
257PyCursesPanel_replace_panel(PyCursesPanelObject *self, PyObject *args)
258{
259 PyCursesPanelObject *po;
260 PyCursesWindowObject *temp;
261 int rtn;
262
263 if (PyTuple_Size(args) != 1) {
264 PyErr_SetString(PyExc_TypeError, "replace requires one argument");
265 return NULL;
266 }
267 if (!PyArg_ParseTuple(args, "O!;window object",
268 &PyCursesWindow_Type, &temp))
269 return NULL;
270
271 po = find_po(self->pan);
272 if (po == NULL) {
273 PyErr_SetString(PyExc_RuntimeError,
274 "replace_panel: can't find Panel Object");
275 return NULL;
276 }
277
278 rtn = replace_panel(self->pan, temp->win);
279 if (rtn == ERR) {
280 PyErr_SetString(PyCursesError, "replace_panel() returned ERR");
281 return NULL;
282 }
283 Py_DECREF(po->wo);
284 po->wo = temp;
285 Py_INCREF(po->wo);
286 Py_INCREF(Py_None);
287 return Py_None;
288}
289
290static PyObject *
291PyCursesPanel_set_panel_userptr(PyCursesPanelObject *self, PyObject *obj)
292{
293 Py_INCREF(obj);
294 return PyCursesCheckERR(set_panel_userptr(self->pan, (void*)obj),
295 "set_panel_userptr");
296}
297
298static PyObject *
299PyCursesPanel_userptr(PyCursesPanelObject *self)
300{
301 PyObject *obj;
302 PyCursesInitialised;
303 obj = (PyObject *) panel_userptr(self->pan);
304 if (obj == NULL) {
305 PyErr_SetString(PyCursesError, "no userptr set");
306 return NULL;
307 }
308
309 Py_INCREF(obj);
310 return obj;
311}
312
313
314/* Module interface */
315
316static PyMethodDef PyCursesPanel_Methods[] = {
317 {"above", (PyCFunction)PyCursesPanel_above, METH_NOARGS},
318 {"below", (PyCFunction)PyCursesPanel_below, METH_NOARGS},
319 {"bottom", (PyCFunction)PyCursesPanel_bottom_panel, METH_NOARGS},
320 {"hidden", (PyCFunction)PyCursesPanel_panel_hidden, METH_NOARGS},
321 {"hide", (PyCFunction)PyCursesPanel_hide_panel, METH_NOARGS},
322 {"move", (PyCFunction)PyCursesPanel_move_panel, METH_VARARGS},
323 {"replace", (PyCFunction)PyCursesPanel_replace_panel, METH_VARARGS},
324 {"set_userptr", (PyCFunction)PyCursesPanel_set_panel_userptr, METH_O},
325 {"show", (PyCFunction)PyCursesPanel_show_panel, METH_NOARGS},
326 {"top", (PyCFunction)PyCursesPanel_top_panel, METH_NOARGS},
327 {"userptr", (PyCFunction)PyCursesPanel_userptr, METH_NOARGS},
328 {"window", (PyCFunction)PyCursesPanel_window, METH_NOARGS},
329 {NULL, NULL} /* sentinel */
330};
331
332static PyObject *
333PyCursesPanel_GetAttr(PyCursesPanelObject *self, char *name)
334{
335 return Py_FindMethod(PyCursesPanel_Methods, (PyObject *)self, name);
336}
337
338/* -------------------------------------------------------*/
339
340PyTypeObject PyCursesPanel_Type = {
341 PyObject_HEAD_INIT(NULL)
342 0, /*ob_size*/
343 "_curses_panel.curses panel", /*tp_name*/
344 sizeof(PyCursesPanelObject), /*tp_basicsize*/
345 0, /*tp_itemsize*/
346 /* methods */
347 (destructor)PyCursesPanel_Dealloc, /*tp_dealloc*/
348 0, /*tp_print*/
349 (getattrfunc)PyCursesPanel_GetAttr, /*tp_getattr*/
350 (setattrfunc)0, /*tp_setattr*/
351 0, /*tp_compare*/
352 0, /*tp_repr*/
353 0, /*tp_as_number*/
354 0, /*tp_as_sequence*/
355 0, /*tp_as_mapping*/
356 0, /*tp_hash*/
357};
358
359/* Wrapper for panel_above(NULL). This function returns the bottom
360 panel of the stack, so it's renamed to bottom_panel().
361 panel.above() *requires* a panel object in the first place which
362 may be undesirable. */
363static PyObject *
364PyCurses_bottom_panel(PyObject *self)
365{
366 PANEL *pan;
367 PyCursesPanelObject *po;
368
369 PyCursesInitialised;
370
371 pan = panel_above(NULL);
372
373 if (pan == NULL) { /* valid output, it means
374 there's no panel at all */
375 Py_INCREF(Py_None);
376 return Py_None;
377 }
378 po = find_po(pan);
379 if (po == NULL) {
380 PyErr_SetString(PyExc_RuntimeError,
381 "panel_above: can't find Panel Object");
382 return NULL;
383 }
384 Py_INCREF(po);
385 return (PyObject *)po;
386}
387
388static PyObject *
389PyCurses_new_panel(PyObject *self, PyObject *args)
390{
391 PyCursesWindowObject *win;
392 PANEL *pan;
393
394 if (!PyArg_ParseTuple(args, "O!", &PyCursesWindow_Type, &win))
395 return NULL;
396 pan = new_panel(win->win);
397 if (pan == NULL) {
398 PyErr_SetString(PyCursesError, catchall_NULL);
399 return NULL;
400 }
401 return (PyObject *)PyCursesPanel_New(pan, win);
402}
403
404
405/* Wrapper for panel_below(NULL). This function returns the top panel
406 of the stack, so it's renamed to top_panel(). panel.below()
407 *requires* a panel object in the first place which may be
408 undesirable. */
409static PyObject *
410PyCurses_top_panel(PyObject *self)
411{
412 PANEL *pan;
413 PyCursesPanelObject *po;
414
415 PyCursesInitialised;
416
417 pan = panel_below(NULL);
418
419 if (pan == NULL) { /* valid output, it means
420 there's no panel at all */
421 Py_INCREF(Py_None);
422 return Py_None;
423 }
424 po = find_po(pan);
425 if (po == NULL) {
426 PyErr_SetString(PyExc_RuntimeError,
427 "panel_below: can't find Panel Object");
428 return NULL;
429 }
430 Py_INCREF(po);
431 return (PyObject *)po;
432}
433
434static PyObject *PyCurses_update_panels(PyObject *self)
435{
436 PyCursesInitialised;
437 update_panels();
438 Py_INCREF(Py_None);
439 return Py_None;
440}
441
442
443/* List of functions defined in the module */
444
445static PyMethodDef PyCurses_methods[] = {
446 {"bottom_panel", (PyCFunction)PyCurses_bottom_panel, METH_NOARGS},
447 {"new_panel", (PyCFunction)PyCurses_new_panel, METH_VARARGS},
448 {"top_panel", (PyCFunction)PyCurses_top_panel, METH_NOARGS},
449 {"update_panels", (PyCFunction)PyCurses_update_panels, METH_NOARGS},
450 {NULL, NULL} /* sentinel */
451};
452
453/* Initialization function for the module */
454
455PyMODINIT_FUNC
456init_curses_panel(void)
457{
458 PyObject *m, *d, *v;
459
460 /* Initialize object type */
461 PyCursesPanel_Type.ob_type = &PyType_Type;
462
463 import_curses();
464
465 /* Create the module and add the functions */
466 m = Py_InitModule("_curses_panel", PyCurses_methods);
467 if (m == NULL)
468 return;
469 d = PyModule_GetDict(m);
470
471 /* For exception _curses_panel.error */
472 PyCursesError = PyErr_NewException("_curses_panel.error", NULL, NULL);
473 PyDict_SetItemString(d, "error", PyCursesError);
474
475 /* Make the version available */
476 v = PyString_FromString(PyCursesVersion);
477 PyDict_SetItemString(d, "version", v);
478 PyDict_SetItemString(d, "__version__", v);
479 Py_DECREF(v);
480}
Note: See TracBrowser for help on using the repository browser.