Modules/_curses_panel.c

   1 /*
   2  *   Interface to the ncurses panel library
   3  *
   4  * Original version by Thomas Gellekum
   5  */
   6
   7 /* Release Number */
   8
   9 static char *PyCursesVersion = "2.1";
  10
  11 /* Includes */
  12
  13 #include "Python.h"
  14
  15 #include "py_curses.h"
  16
  17 #include <panel.h>
  18
  19 static 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
  29 static PyObject *
  30 PyCursesCheckERR(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
  51 typedef struct {
  52     PyObject_HEAD
  53     PANEL *pan;
  54     PyCursesWindowObject *wo;   /* for reference counts */
  55 } PyCursesPanelObject;
  56
  57 PyTypeObject 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. */
  78 typedef struct _list_of_panels {
  79     PyCursesPanelObject *po;
  80     struct _list_of_panels *next;
  81 } list_of_panels;
  82
  83 /* list anchor */
  84 static list_of_panels *lop;
  85
  86 /* Insert a new panel object into lop */
  87 static int
  88 insert_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 */
 103 static void
 104 remove_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 */
 129 static PyCursesPanelObject *
 130 find_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) \
 146 static PyObject *PyCursesPanel_##X(PyCursesPanelObject *self) \
 147 { return PyCursesCheckERR(X(self->pan), # X); }
 148
 149 #define Panel_NoArgTrueFalseFunction(X) \
 150 static 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) \
 156 static 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
 164 Panel_NoArgNoReturnFunction(bottom_panel)
 165 Panel_NoArgNoReturnFunction(hide_panel)
 166 Panel_NoArgNoReturnFunction(show_panel)
 167 Panel_NoArgNoReturnFunction(top_panel)
 168 Panel_NoArgTrueFalseFunction(panel_hidden)
 169 Panel_TwoArgNoReturnFunction(move_panel, int, "ii;y,x")
 170
 171 /* Allocation and deallocation of Panel Objects */
 172
 173 static PyObject *
 174 PyCursesPanel_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
 190 static void
 191 PyCursesPanel_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(). */
 201 static PyObject *
 202 PyCursesPanel_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(). */
 226 static PyObject *
 227 PyCursesPanel_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
 249 static PyObject *
 250 PyCursesPanel_window(PyCursesPanelObject *self)
 251 {
 252     Py_INCREF(self->wo);
 253     return (PyObject *)self->wo;
 254 }
 255
 256 static PyObject *
 257 PyCursesPanel_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
 290 static PyObject *
 291 PyCursesPanel_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
 298 static PyObject *
 299 PyCursesPanel_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
 316 static 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
 332 static PyObject *
 333 PyCursesPanel_GetAttr(PyCursesPanelObject *self, char *name)
 334 {
 335     return Py_FindMethod(PyCursesPanel_Methods, (PyObject *)self, name);
 336 }
 337
 338 /* -------------------------------------------------------*/
 339
 340 PyTypeObject 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. */
 363 static PyObject *
 364 PyCurses_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
 388 static PyObject *
 389 PyCurses_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. */
 409 static PyObject *
 410 PyCurses_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
 434 static 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
 445 static 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
 455 PyMODINIT_FUNC
 456 init_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 }