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)	 (Py_TYPE(v) == &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     PyVarObject_HEAD_INIT(NULL, 0)

   342     "_curses_panel.curses panel",	/*tp_name*/

   343     sizeof(PyCursesPanelObject),	/*tp_basicsize*/

   344     0,			/*tp_itemsize*/

   345     /* methods */

   346     (destructor)PyCursesPanel_Dealloc, /*tp_dealloc*/

   347     0,			/*tp_print*/

   348     (getattrfunc)PyCursesPanel_GetAttr, /*tp_getattr*/

   349     (setattrfunc)0, /*tp_setattr*/

   350     0,			/*tp_compare*/

   351     0,			/*tp_repr*/

   352     0,			/*tp_as_number*/

   353     0,			/*tp_as_sequence*/

   354     0,			/*tp_as_mapping*/

   355     0,			/*tp_hash*/

   356 };

   357 

   358 /* Wrapper for panel_above(NULL). This function returns the bottom

   359    panel of the stack, so it's renamed to bottom_panel().

   360    panel.above() *requires* a panel object in the first place which

   361    may be undesirable. */

   362 static PyObject *

   363 PyCurses_bottom_panel(PyObject *self)

   364 {

   365     PANEL *pan;

   366     PyCursesPanelObject *po;

   367 

   368     PyCursesInitialised;

   369 

   370     pan = panel_above(NULL);

   371 

   372     if (pan == NULL) {		/* valid output, it means

   373 				   there's no panel at all */  

   374 	Py_INCREF(Py_None);

   375 	return Py_None;

   376     }

   377     po = find_po(pan);

   378     if (po == NULL) {

   379 	PyErr_SetString(PyExc_RuntimeError,

   380 			"panel_above: can't find Panel Object");

   381 	return NULL;

   382     }

   383     Py_INCREF(po);

   384     return (PyObject *)po;

   385 }

   386 

   387 static PyObject *

   388 PyCurses_new_panel(PyObject *self, PyObject *args)

   389 {

   390     PyCursesWindowObject *win;

   391     PANEL *pan;

   392 

   393     if (!PyArg_ParseTuple(args, "O!", &PyCursesWindow_Type, &win))

   394         return NULL;

   395     pan = new_panel(win->win);

   396     if (pan == NULL) {

   397 	PyErr_SetString(PyCursesError, catchall_NULL);

   398 	return NULL;

   399     }

   400     return (PyObject *)PyCursesPanel_New(pan, win);

   401 }

   402 

   403 

   404 /* Wrapper for panel_below(NULL). This function returns the top panel

   405    of the stack, so it's renamed to top_panel(). panel.below()

   406    *requires* a panel object in the first place which may be

   407    undesirable. */

   408 static PyObject *

   409 PyCurses_top_panel(PyObject *self)

   410 {

   411     PANEL *pan;

   412     PyCursesPanelObject *po;

   413     

   414     PyCursesInitialised;

   415 

   416     pan = panel_below(NULL);

   417 

   418     if (pan == NULL) {		/* valid output, it means

   419 				   there's no panel at all */

   420 	Py_INCREF(Py_None);

   421 	return Py_None;

   422     }

   423     po = find_po(pan);

   424     if (po == NULL) {

   425 	PyErr_SetString(PyExc_RuntimeError,

   426 			"panel_below: can't find Panel Object");

   427 	return NULL;

   428     }

   429     Py_INCREF(po);

   430     return (PyObject *)po;

   431 }

   432 

   433 static PyObject *PyCurses_update_panels(PyObject *self)

   434 { 

   435     PyCursesInitialised;

   436     update_panels();

   437     Py_INCREF(Py_None);

   438     return Py_None;

   439 }

   440 

   441 

   442 /* List of functions defined in the module */

   443 

   444 static PyMethodDef PyCurses_methods[] = {

   445     {"bottom_panel",        (PyCFunction)PyCurses_bottom_panel,  METH_NOARGS},

   446     {"new_panel",           (PyCFunction)PyCurses_new_panel,     METH_VARARGS},

   447     {"top_panel",           (PyCFunction)PyCurses_top_panel,     METH_NOARGS},

   448     {"update_panels",       (PyCFunction)PyCurses_update_panels, METH_NOARGS},

   449     {NULL,		NULL}		/* sentinel */

   450 };

   451 

   452 /* Initialization function for the module */

   453 

   454 PyMODINIT_FUNC

   455 init_curses_panel(void)

   456 {

   457     PyObject *m, *d, *v;

   458 

   459     /* Initialize object type */

   460     Py_TYPE(&PyCursesPanel_Type) = &PyType_Type;

   461 

   462     import_curses();

   463 

   464     /* Create the module and add the functions */

   465     m = Py_InitModule("_curses_panel", PyCurses_methods);

   466     if (m == NULL)

   467     	return;

   468     d = PyModule_GetDict(m);

   469 

   470     /* For exception _curses_panel.error */

   471     PyCursesError = PyErr_NewException("_curses_panel.error", NULL, NULL);

   472     PyDict_SetItemString(d, "error", PyCursesError);

   473 

   474     /* Make the version available */

   475     v = PyString_FromString(PyCursesVersion);

   476     PyDict_SetItemString(d, "version", v);

   477     PyDict_SetItemString(d, "__version__", v);

   478     Py_DECREF(v);

   479 }