Lance has converted his modules to the new naming conventions, and

contributed a curses interface.
Setup.in uses .c instead of .o now.

1 files changed, 1298 insertions, 0 deletions

diff --git a/Modules/_cursesmodule.c b/Modules/_cursesmodule.c
new file mode 100644
index 0000000..0fdf710
--- /dev/null
+++ b/Modules/_cursesmodule.c
@@ -0,0 +1,1298 @@
+/***********************************************************
+Copyright 1994 by Lance Ellinghouse,
+Cathedral City, California Republic, United States of America.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its 
+documentation for any purpose and without fee is hereby granted, 
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in 
+supporting documentation, and that the name of Lance Ellinghouse
+not be used in advertising or publicity pertaining to distribution 
+of the software without specific, written prior permission.
+
+LANCE ELLINGHOUSE DISCLAIMS ALL WARRANTIES WITH REGARD TO
+THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS, IN NO EVENT SHALL LANCE ELLINGHOUSE BE LIABLE FOR ANY SPECIAL, 
+INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING 
+FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, 
+NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION 
+WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+******************************************************************/
+
+/* curses module */
+
+#include "allobjects.h"
+#include "fileobject.h"
+#include "modsupport.h"
+
+#include <curses.h>
+
+#include "rename1.h"
+
+typedef struct {
+	PyObject_HEAD
+	SCREEN *scr;
+} PyCursesScreenObject;
+
+typedef struct {
+	PyObject_HEAD
+	WINDOW *win;
+	WINDOW *parent;
+} PyCursesWindowObject;
+
+typedef struct {
+	PyObject_HEAD
+	WINDOW *pad;
+} PyCursesPadObject;
+
+staticforward PyTypeObject PyCursesScreen_Type;
+staticforward PyTypeObject PyCursesWindow_Type;
+staticforward PyTypeObject PyCursesPad_Type;
+
+#define PyCursesScreen_Check(v)	 ((v)->ob_type == &PyCursesScreen_Type)
+#define PyCursesWindow_Check(v)	 ((v)->ob_type == &PyCursesWindow_Type)
+#define PyCursesPad_Check(v)	 ((v)->ob_type == &PyCursesPad_Type)
+
+/* Defines */
+PyObject *PyCurses_OK;
+PyObject *PyCurses_ERR;
+
+/* ------------- SCREEN routines --------------- */
+#ifdef NOT_YET
+static PyObject *
+PyCursesScreen_New(arg)
+	PyObject * arg;
+{
+        char *term_type;
+	PyFileObject *in_fo;
+	PyFileObject *out_fo;
+	PyCursesScreenObject *xp;
+	xp = (PyObject *)PyObject_NEW(PyCursesScreenObject, &PyCursesScreen_Type);
+	if (xp == NULL)
+		return NULL;
+	return (PyObject *)xp;
+}
+#endif
+/* ------------- WINDOW routines --------------- */
+static PyObject *
+PyCursesWindow_New(win)
+	WINDOW *win;
+{
+	PyCursesWindowObject *wo;
+	wo = (PyCursesWindowObject *)PyObject_NEW(PyCursesWindowObject, &PyCursesWindow_Type);
+	if (wo == NULL)
+		return NULL;
+	wo->win = win;
+	wo->parent = (WINDOW *)NULL;
+	return (PyObject *)wo;
+}
+
+static void
+PyCursesWindow_Dealloc(wo)
+	PyCursesWindowObject *wo;
+{
+  if (wo->win != stdscr)
+    delwin(wo->win);
+  PyMem_DEL(wo);
+}
+
+static PyObject *
+PyCursesWindow_Refresh(self,arg)
+     PyCursesWindowObject *self;
+     PyObject * arg;
+{
+  if (!PyArg_NoArgs(arg))
+    return (PyObject *)NULL;
+  return (PyObject *)PyInt_FromLong(wrefresh(self->win));
+}
+
+static PyObject *
+PyCursesWindow_NoOutRefresh(self,arg)
+     PyCursesWindowObject *self;
+     PyObject * arg;
+{
+  if (!PyArg_NoArgs(arg))
+    return (PyObject *)NULL;
+  return (PyObject *)PyInt_FromLong(wnoutrefresh(self->win));
+}
+
+static PyObject *
+PyCursesWindow_MoveWin(self,arg)
+     PyCursesWindowObject *self;
+     PyObject * arg;
+{
+  int rtn;
+  int x, y;
+  if (!PyArg_Parse(arg,"(ii)", &y, &x))
+    return (PyObject *)NULL;
+  rtn = mvwin(self->win,y,x);
+  if (rtn == OK) {
+    Py_INCREF(PyCurses_OK);
+    return (PyObject *)PyCurses_OK;
+  }
+  Py_INCREF(PyCurses_ERR);
+  return (PyObject *)PyCurses_ERR;
+}
+
+static PyObject *
+PyCursesWindow_Move(self,arg)
+     PyCursesWindowObject *self;
+     PyObject * arg;
+{
+  int rtn;
+  int x, y;
+  if (!PyArg_Parse(arg,"(ii)", &y, &x))
+    return (PyObject *)NULL;
+  rtn = wmove(self->win,y,x);
+  if (rtn == OK) {
+    Py_INCREF(PyCurses_OK);
+    return (PyObject *)PyCurses_OK;
+  }
+  Py_INCREF(PyCurses_ERR);
+  return (PyObject *)PyCurses_ERR;
+}
+
+static PyObject *
+PyCursesWindow_SubWin(self,arg)
+     PyCursesWindowObject *self;
+     PyObject * arg;
+{
+  WINDOW *win;
+  PyCursesWindowObject *rtn_win;
+  int nlines, ncols, begin_y, begin_x;
+  nlines = 0;
+  ncols  = 0;
+  if (!PyArg_Parse(arg,
+		   "(iiii);nlines,ncols,begin_y,begin_x",
+		   &nlines,&ncols,&begin_y,&begin_x))
+    if (!PyArg_Parse(arg,"(ii)",&begin_y,&begin_x))
+      return (PyObject *)NULL;
+  win = subwin(self->win,nlines,ncols,begin_y,begin_x);
+  if (win == NULL) {
+    Py_INCREF(Py_None);
+    return (PyObject *)Py_None;
+  }
+  rtn_win = (PyCursesWindowObject *)PyCursesWindow_New(win);
+  rtn_win->parent = self->win;
+  return (PyObject *)rtn_win;
+}
+
+static PyObject *
+PyCursesWindow_AddCh(self,arg)
+     PyCursesWindowObject *self;
+     PyObject * arg;
+{
+  int rtn;
+  int x, y;
+  int ch;
+  int attr;
+  int attr_old;
+  int use_xy = TRUE;
+  int use_attr = TRUE;
+  switch (PyTuple_Size(arg)) {
+    case 2:
+    case 4:
+      use_attr = TRUE;
+      break;
+    default:
+      use_attr = FALSE;
+    }
+  if (!PyArg_Parse(arg,"(iiii);y,x,ch,attr", &y, &x, &ch, &attr)) {
+    if (!PyArg_Parse(arg,"(iii);y,x,ch", &y, &x, &ch)) {
+      use_xy = FALSE;
+      if (!PyArg_Parse(arg,"(ii);ch,attr", &ch, &attr))
+	if (!PyArg_Parse(arg,"i;ch", &ch))
+	  return (PyObject *)NULL;
+    }
+  }
+  if (use_attr == TRUE) {
+    attr_old = getattrs(self->win);
+    wattrset(self->win,attr);
+  }
+  if (use_xy == TRUE)
+    rtn = mvwaddch(self->win,y,x,ch);
+  else
+    rtn = waddch(self->win,ch);
+  if (use_attr == TRUE)
+    wattrset(self->win,attr_old);
+  if (rtn == OK) {
+    Py_INCREF(PyCurses_OK);
+    return (PyObject *)PyCurses_OK;
+  }
+  Py_INCREF(PyCurses_ERR);
+  return (PyObject *)PyCurses_ERR;
+}
+
+static PyObject *
+PyCursesWindow_InsCh(self,arg)
+     PyCursesWindowObject *self;
+     PyObject * arg;
+{
+  int rtn;
+  int x, y;
+  int ch;
+  int use_xy = TRUE;
+  int attr, attr_old, use_attr = FALSE;
+  switch (PyTuple_Size(arg)) {
+    case 2:
+    case 4:
+      use_attr = TRUE;
+      break;
+    default:
+      use_attr = FALSE;
+    }
+  if (!PyArg_Parse(arg,"(iiii);y,x,ch,attr", &y, &x, &ch, &attr)) {
+    if (!PyArg_Parse(arg,"(iii);y,x,ch", &y, &x, &ch)) {
+      use_xy = FALSE;
+      if (!PyArg_Parse(arg,"(ii);ch,attr", &ch, &attr))
+	if (!PyArg_Parse(arg,"i;ch", &ch))
+	  return (PyObject *)NULL;
+    }
+  }
+  if (use_attr == TRUE) {
+    attr_old = getattrs(self->win);
+    wattrset(self->win,attr);
+  }
+  if (use_xy == TRUE)
+    rtn = mvwinsch(self->win,y,x,ch);
+  else
+    rtn = winsch(self->win,ch);
+  if (use_attr == TRUE)
+    wattrset(self->win,attr_old);
+  if (rtn == OK) {
+    Py_INCREF(PyCurses_OK);
+    return (PyObject *)PyCurses_OK;
+  }
+  Py_INCREF(PyCurses_ERR);
+  return (PyObject *)PyCurses_ERR;
+}
+
+static PyObject *
+PyCursesWindow_DelCh(self,arg)
+     PyCursesWindowObject *self;
+     PyObject * arg;
+{
+  int rtn;
+  int x, y;
+  int use_xy = TRUE;
+  if (!PyArg_Parse(arg,"(ii);y,x", &y, &x))
+    use_xy = FALSE;
+  if (use_xy == TRUE)
+    rtn = mvwdelch(self->win,y,x);
+  else
+    rtn = wdelch(self->win);
+  if (rtn == OK) {
+    Py_INCREF(PyCurses_OK);
+    return (PyObject *)PyCurses_OK;
+  }
+  Py_INCREF(PyCurses_ERR);
+  return (PyObject *)PyCurses_ERR;
+}
+
+static PyObject *
+PyCursesWindow_EchoChar(self,arg)
+     PyCursesWindowObject *self;
+     PyObject * arg;
+{
+  int rtn;
+  int ch;
+  int attr, attr_old, use_attr = TRUE;
+  if (!PyArg_Parse(arg,"(ii);ch,attr", &ch, &attr)) {
+    use_attr = FALSE;
+    if (!PyArg_Parse(arg,"i;ch", &ch))
+      return (PyObject *)NULL;
+  }
+  if (use_attr == TRUE) {
+    attr_old = getattrs(self->win);
+    wattrset(self->win,attr);
+  }
+  rtn = wechochar(self->win,ch);
+  if (use_attr == TRUE)
+    wattrset(self->win,attr_old);
+  if (rtn == OK) {
+    Py_INCREF(PyCurses_OK);
+    return (PyObject *)PyCurses_OK;
+  }
+  Py_INCREF(PyCurses_ERR);
+  return (PyObject *)PyCurses_ERR;
+}
+
+static PyObject *
+PyCursesWindow_AddStr(self,arg)
+     PyCursesWindowObject *self;
+     PyObject * arg;
+{
+  int rtn;
+  int x, y;
+  char *str;
+  int use_xy = TRUE;
+  int attr, attr_old, use_attr = TRUE;
+    switch (PyTuple_Size(arg)) {
+    case 2:
+    case 4:
+      use_attr = TRUE;
+      break;
+    default:
+      use_attr = FALSE;
+    }
+  if (!PyArg_Parse(arg,"(iisi);y,x,str,attr", &y, &x, &str, &attr)) {
+    if (!PyArg_Parse(arg,"(iis);y,x,str", &y, &x, &str)) {
+      use_xy = FALSE;
+      if (!PyArg_Parse(arg,"(si);str,attr", &str, &attr))
+	if (!PyArg_Parse(arg,"s;str", &str))
+	  return (PyObject *)NULL;
+    }
+  }
+  if (use_attr == TRUE) {
+    attr_old = getattrs(self->win);
+    wattrset(self->win,attr);
+  }
+  if (use_xy == TRUE)
+    rtn = mvwaddstr(self->win,y,x,str);
+  else
+    rtn = waddstr(self->win,str);
+  if (use_attr == TRUE)
+    wattrset(self->win,attr_old);
+  if (rtn == OK) {
+    Py_INCREF(PyCurses_OK);
+    return (PyObject *)PyCurses_OK;
+  }
+  Py_INCREF(PyCurses_ERR);
+  return (PyObject *)PyCurses_ERR;
+}
+
+static PyObject *
+PyCursesWindow_AttrOn(self,arg)
+     PyCursesWindowObject *self;
+     PyObject * arg;
+{
+  int rtn;
+  int ch;
+  if (!PyArg_Parse(arg,"i;attr", &ch))
+      return (PyObject *)NULL;
+  rtn = wattron(self->win,ch);
+  if (rtn == OK) {
+    Py_INCREF(PyCurses_OK);
+    return (PyObject *)PyCurses_OK;
+  }
+  Py_INCREF(PyCurses_ERR);
+  return (PyObject *)PyCurses_ERR;
+}
+
+static PyObject *
+PyCursesWindow_AttrOff(self,arg)
+     PyCursesWindowObject *self;
+     PyObject * arg;
+{
+  int rtn;
+  int ch;
+  if (!PyArg_Parse(arg,"i;attr", &ch))
+      return (PyObject *)NULL;
+  rtn = wattroff(self->win,ch);
+  if (rtn == OK) {
+    Py_INCREF(PyCurses_OK);
+    return (PyObject *)PyCurses_OK;
+  }
+  Py_INCREF(PyCurses_ERR);
+  return (PyObject *)PyCurses_ERR;
+}
+
+static PyObject *
+PyCursesWindow_AttrSet(self,arg)
+     PyCursesWindowObject *self;
+     PyObject * arg;
+{
+  int rtn;
+  int ch;
+  if (!PyArg_Parse(arg,"i;attr", &ch))
+      return (PyObject *)NULL;
+  rtn = wattrset(self->win,ch);
+  if (rtn == OK) {
+    Py_INCREF(PyCurses_OK);
+    return (PyObject *)PyCurses_OK;
+  }
+  Py_INCREF(PyCurses_ERR);
+  return (PyObject *)PyCurses_ERR;
+}
+
+static PyObject *
+PyCursesWindow_StandEnd(self,arg)
+     PyCursesWindowObject *self;
+     PyObject * arg;
+{
+  int rtn;
+  if (!PyArg_NoArgs(arg))
+      return (PyObject *)NULL;
+  rtn = wstandend(self->win);
+  if (rtn == OK) {
+    Py_INCREF(PyCurses_OK);
+    return (PyObject *)PyCurses_OK;
+  }
+  Py_INCREF(PyCurses_ERR);
+  return (PyObject *)PyCurses_ERR;
+}
+
+static PyObject *
+PyCursesWindow_StandOut(self,arg)
+     PyCursesWindowObject *self;
+     PyObject * arg;
+{
+  int rtn;
+  if (!PyArg_NoArgs(arg))
+      return (PyObject *)NULL;
+  rtn = wstandout(self->win);
+  if (rtn == OK) {
+    Py_INCREF(PyCurses_OK);
+    return (PyObject *)PyCurses_OK;
+  }
+  Py_INCREF(PyCurses_ERR);
+  return (PyObject *)PyCurses_ERR;
+}
+
+static PyObject *
+PyCursesWindow_Box(self,arg)
+     PyCursesWindowObject *self;
+     PyObject * arg;
+{
+  int rtn;
+  int ch1=0,ch2=0;
+  if (!PyArg_Parse(arg,"(ii);vertch,horch", &ch1, &ch2))
+    PyErr_Clear();
+  rtn = box(self->win,ch1,ch2);
+  if (rtn == OK) {
+    Py_INCREF(PyCurses_OK);
+    return (PyObject *)PyCurses_OK;
+  }
+  Py_INCREF(PyCurses_ERR);
+  return (PyObject *)PyCurses_ERR;
+}
+
+static PyObject *
+PyCursesWindow_Erase(self,arg)
+     PyCursesWindowObject *self;
+     PyObject * arg;
+{
+  if (!PyArg_NoArgs(arg))
+      return (PyObject *)NULL;
+  werase(self->win);
+  Py_INCREF(Py_None);
+  return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCursesWindow_DeleteLine(self,arg)
+     PyCursesWindowObject *self;
+     PyObject * arg;
+{
+  if (!PyArg_NoArgs(arg))
+      return (PyObject *)NULL;
+  wdeleteln(self->win);
+  Py_INCREF(Py_None);
+  return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCursesWindow_InsertLine(self,arg)
+     PyCursesWindowObject *self;
+     PyObject * arg;
+{
+  if (!PyArg_NoArgs(arg))
+      return (PyObject *)NULL;
+  winsertln(self->win);
+  Py_INCREF(Py_None);
+  return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCursesWindow_GetYX(self,arg)
+     PyCursesWindowObject *self;
+     PyObject * arg;
+{
+  int x, y;
+  if (!PyArg_NoArgs(arg))
+      return (PyObject *)NULL;
+  getyx(self->win,y,x);
+  return (PyObject *)Py_BuildValue("(ii)", y, x);
+}
+
+static PyObject *
+PyCursesWindow_GetBegYX(self,arg)
+     PyCursesWindowObject *self;
+     PyObject * arg;
+{
+  int x, y;
+  if (!PyArg_NoArgs(arg))
+      return (PyObject *)NULL;
+  getbegyx(self->win,y,x);
+  return (PyObject *)Py_BuildValue("(ii)", y, x);
+}
+
+static PyObject *
+PyCursesWindow_GetMaxYX(self,arg)
+     PyCursesWindowObject *self;
+     PyObject * arg;
+{
+  int x, y;
+  if (!PyArg_NoArgs(arg))
+      return (PyObject *)NULL;
+  getmaxyx(self->win,y,x);
+  return (PyObject *)Py_BuildValue("(ii)", y, x);
+}
+
+static PyObject *
+PyCursesWindow_Clear(self,arg)
+     PyCursesWindowObject *self;
+     PyObject * arg;
+{
+  if (!PyArg_NoArgs(arg))
+      return (PyObject *)NULL;
+  wclear(self->win);
+  Py_INCREF(Py_None);
+  return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCursesWindow_ClearToBottom(self,arg)
+     PyCursesWindowObject *self;
+     PyObject * arg;
+{
+  if (!PyArg_NoArgs(arg))
+      return (PyObject *)NULL;
+  wclrtobot(self->win);
+  Py_INCREF(Py_None);
+  return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCursesWindow_ClearToEOL(self,arg)
+     PyCursesWindowObject *self;
+     PyObject * arg;
+{
+  if (!PyArg_NoArgs(arg))
+      return (PyObject *)NULL;
+  wclrtoeol(self->win);
+  Py_INCREF(Py_None);
+  return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCursesWindow_Scroll(self,arg)
+     PyCursesWindowObject *self;
+     PyObject * arg;
+{
+  if (!PyArg_NoArgs(arg))
+      return (PyObject *)NULL;
+  scroll(self->win);
+  Py_INCREF(Py_None);
+  return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCursesWindow_TouchWin(self,arg)
+     PyCursesWindowObject *self;
+     PyObject * arg;
+{
+  if (!PyArg_NoArgs(arg))
+      return (PyObject *)NULL;
+  touchwin(self->win);
+  Py_INCREF(Py_None);
+  return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCursesWindow_TouchLine(self,arg)
+     PyCursesWindowObject *self;
+     PyObject * arg;
+{
+  int st, cnt;
+  if (!PyArg_Parse(arg,"(ii);start, count",&st,&cnt))
+      return (PyObject *)NULL;
+  touchline(self->win,st,cnt);
+  Py_INCREF(Py_None);
+  return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCursesWindow_GetCh(self,arg)
+     PyCursesWindowObject *self;
+     PyObject * arg;
+{
+  int x, y;
+  int use_xy = TRUE;
+  int rtn;
+  if (!PyArg_Parse(arg,"(ii);y,x",&y,&x))
+    use_xy = FALSE;
+  if (use_xy == TRUE)
+    rtn = mvwgetch(self->win,y,x);
+  else
+    rtn = wgetch(self->win);
+  return (PyObject *)PyInt_FromLong(rtn);
+}
+
+static PyObject *
+PyCursesWindow_GetStr(self,arg)
+     PyCursesWindowObject *self;
+     PyObject * arg;
+{
+  int x, y;
+  int use_xy = TRUE;
+  char rtn[1024]; /* This should be big enough.. I hope */
+  int rtn2;
+  if (!PyArg_Parse(arg,"(ii);y,x",&y,&x))
+    use_xy = FALSE;
+  if (use_xy == TRUE)
+    rtn2 = mvwgetstr(self->win,y,x,rtn);
+  else
+    rtn2 = wgetstr(self->win,rtn);
+  if (rtn2 == ERR)
+    rtn[0] = 0;
+  return (PyObject *)PyString_FromString(rtn);
+}
+
+static PyObject *
+PyCursesWindow_InCh(self,arg)
+     PyCursesWindowObject *self;
+     PyObject * arg;
+{
+  int x, y;
+  int use_xy = TRUE;
+  int rtn;
+  if (!PyArg_Parse(arg,"(ii);y,x",&y,&x))
+    use_xy = FALSE;
+  if (use_xy == TRUE)
+    rtn = mvwinch(self->win,y,x);
+  else
+    rtn = winch(self->win);
+  return (PyObject *)PyInt_FromLong(rtn);
+}
+
+static PyObject *
+PyCursesWindow_ClearOk(self,arg)
+     PyCursesWindowObject *self;
+     PyObject * arg;
+{
+  int val;
+  if (!PyArg_Parse(arg,"i;True(1) or False(0)",&val))
+    return (PyObject *)NULL;
+  clearok(self->win,val);
+  Py_INCREF(Py_None);
+  return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCursesWindow_IdlOk(self,arg)
+     PyCursesWindowObject *self;
+     PyObject * arg;
+{
+  int val;
+  if (!PyArg_Parse(arg,"i;True(1) or False(0)",&val))
+    return (PyObject *)NULL;
+  idlok(self->win,val);
+  Py_INCREF(Py_None);
+  return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCursesWindow_LeaveOk(self,arg)
+     PyCursesWindowObject *self;
+     PyObject * arg;
+{
+  int val;
+  if (!PyArg_Parse(arg,"i;True(1) or False(0)",&val))
+    return (PyObject *)NULL;
+  leaveok(self->win,val);
+  Py_INCREF(Py_None);
+  return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCursesWindow_ScrollOk(self,arg)
+     PyCursesWindowObject *self;
+     PyObject * arg;
+{
+  int val;
+  if (!PyArg_Parse(arg,"i;True(1) or False(0)",&val))
+    return (PyObject *)NULL;
+  scrollok(self->win,val);
+  Py_INCREF(Py_None);
+  return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCursesWindow_SetScrollRegion(self,arg)
+     PyCursesWindowObject *self;
+     PyObject * arg;
+{
+  int x, y;
+  if (!PyArg_Parse(arg,"(ii);top, bottom",&y,&x))
+    return (PyObject *)NULL;
+  wsetscrreg(self->win,y,x);
+  Py_INCREF(Py_None);
+  return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCursesWindow_KeyPad(self,arg)
+     PyCursesWindowObject * self;
+     PyObject * arg;
+{
+  int ch;
+  if (!PyArg_Parse(arg,"i;True(1), False(0)",&ch))
+    return (PyObject *)NULL;
+  keypad(self->win,ch);
+  Py_INCREF(Py_None);
+  return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCursesWindow_NoDelay(self,arg)
+     PyCursesWindowObject * self;
+     PyObject * arg;
+{
+  int ch;
+  if (!PyArg_Parse(arg,"i;True(1), False(0)",&ch))
+    return (PyObject *)NULL;
+  nodelay(self->win,ch);
+  Py_INCREF(Py_None);
+  return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCursesWindow_NoTimeout(self,arg)
+     PyCursesWindowObject * self;
+     PyObject * arg;
+{
+  int ch;
+  if (!PyArg_Parse(arg,"i;True(1), False(0)",&ch))
+    return (PyObject *)NULL;
+  notimeout(self->win,ch);
+  Py_INCREF(Py_None);
+  return (PyObject *)Py_None;
+}
+
+static PyMethodDef PyCursesWindow_Methods[] = {
+	{"refresh",             (PyCFunction)PyCursesWindow_Refresh},
+	{"nooutrefresh",        (PyCFunction)PyCursesWindow_NoOutRefresh},
+	{"mvwin",               (PyCFunction)PyCursesWindow_MoveWin},
+	{"move",                (PyCFunction)PyCursesWindow_Move},
+	{"subwin",              (PyCFunction)PyCursesWindow_SubWin},
+	{"addch",               (PyCFunction)PyCursesWindow_AddCh},
+	{"insch",               (PyCFunction)PyCursesWindow_InsCh},
+	{"delch",               (PyCFunction)PyCursesWindow_DelCh},
+	{"echochar",            (PyCFunction)PyCursesWindow_EchoChar},
+	{"addstr",              (PyCFunction)PyCursesWindow_AddStr},
+	{"attron",              (PyCFunction)PyCursesWindow_AttrOn},
+	{"attroff",             (PyCFunction)PyCursesWindow_AttrOff},
+	{"attrset",             (PyCFunction)PyCursesWindow_AttrSet},
+	{"standend",            (PyCFunction)PyCursesWindow_StandEnd},
+	{"standout",            (PyCFunction)PyCursesWindow_StandOut},
+	{"box",                 (PyCFunction)PyCursesWindow_Box},
+	{"erase",               (PyCFunction)PyCursesWindow_Erase},
+	{"deleteln",            (PyCFunction)PyCursesWindow_DeleteLine},
+	{"insertln",            (PyCFunction)PyCursesWindow_InsertLine},
+	{"getyx",               (PyCFunction)PyCursesWindow_GetYX},
+	{"getbegyx",            (PyCFunction)PyCursesWindow_GetBegYX},
+	{"getmaxyx",            (PyCFunction)PyCursesWindow_GetMaxYX},
+	{"clear",               (PyCFunction)PyCursesWindow_Clear},
+	{"clrtobot",            (PyCFunction)PyCursesWindow_ClearToBottom},
+	{"clrtoeol",            (PyCFunction)PyCursesWindow_ClearToEOL},
+	{"scroll",              (PyCFunction)PyCursesWindow_Scroll},
+	{"touchwin",            (PyCFunction)PyCursesWindow_TouchWin},
+	{"touchline",           (PyCFunction)PyCursesWindow_TouchLine},
+	{"getch",               (PyCFunction)PyCursesWindow_GetCh},
+	{"getstr",              (PyCFunction)PyCursesWindow_GetStr},
+	{"inch",                (PyCFunction)PyCursesWindow_InCh},
+	{"clearok",             (PyCFunction)PyCursesWindow_ClearOk},
+	{"idlok",               (PyCFunction)PyCursesWindow_IdlOk},
+	{"leaveok",             (PyCFunction)PyCursesWindow_LeaveOk},
+	{"scrollok",            (PyCFunction)PyCursesWindow_ScrollOk},
+	{"setscrreg",           (PyCFunction)PyCursesWindow_SetScrollRegion},
+	{"keypad",              (PyCFunction)PyCursesWindow_KeyPad},
+	{"nodelay",             (PyCFunction)PyCursesWindow_NoDelay},
+	{"notimeout",           (PyCFunction)PyCursesWindow_NoTimeout},
+	{NULL,		        (PyCFunction)NULL}   /* sentinel */
+};
+
+static PyObject *
+PyCursesWindow_GetAttr(self, name)
+	PyCursesWindowObject *self;
+	char *name;
+{
+  return findmethod(PyCursesWindow_Methods, (PyObject *)self, name);
+}
+
+/* --------------- PAD routines ---------------- */
+static PyObject *
+PyCursesPad_New(pad)
+	WINDOW *pad;
+{
+	PyCursesPadObject *po;
+	po = (PyCursesPadObject *)PyObject_NEW(PyCursesPadObject, &PyCursesPad_Type);
+	if (po == NULL)
+		return NULL;
+	po->pad = pad;
+	return (PyObject *)po;
+}
+
+/* -------------------------------------------------------*/
+static PyTypeObject PyCursesScreen_Type = {
+	PyObject_HEAD_INIT(&PyType_Type)
+	0,			/*ob_size*/
+	"curses screen",	/*tp_name*/
+	sizeof(PyCursesScreenObject),	/*tp_basicsize*/
+	0,			/*tp_itemsize*/
+	/* methods */
+	(destructor)0 /*PyCursesScreen_Dealloc*/, /*tp_dealloc*/
+	0,			/*tp_print*/
+	(getattrfunc)0, /*tp_getattr*/
+	(setattrfunc)0, /*tp_setattr*/
+	0,			/*tp_compare*/
+	0,			/*tp_repr*/
+	0,			/*tp_as_number*/
+	0,			/*tp_as_sequence*/
+	0,			/*tp_as_mapping*/
+	0,			/*tp_hash*/
+};
+
+static PyTypeObject PyCursesWindow_Type = {
+	PyObject_HEAD_INIT(&PyType_Type)
+	0,			/*ob_size*/
+	"curses window",	/*tp_name*/
+	sizeof(PyCursesWindowObject),	/*tp_basicsize*/
+	0,			/*tp_itemsize*/
+	/* methods */
+	(destructor)PyCursesWindow_Dealloc, /*tp_dealloc*/
+	0,			/*tp_print*/
+	(getattrfunc)PyCursesWindow_GetAttr, /*tp_getattr*/
+	(setattrfunc)0, /*tp_setattr*/
+	0,			/*tp_compare*/
+	0,			/*tp_repr*/
+	0,			/*tp_as_number*/
+	0,			/*tp_as_sequence*/
+	0,			/*tp_as_mapping*/
+	0,			/*tp_hash*/
+};
+
+static PyTypeObject PyCursesPad_Type = {
+	PyObject_HEAD_INIT(&PyType_Type)
+	0,			/*ob_size*/
+	"curses pad",	/*tp_name*/
+	sizeof(PyCursesPadObject),	/*tp_basicsize*/
+	0,			/*tp_itemsize*/
+	/* methods */
+	(destructor)0 /*PyCursesPad_Dealloc*/, /*tp_dealloc*/
+	0,			/*tp_print*/
+	(getattrfunc)0, /*tp_getattr*/
+	(setattrfunc)0, /*tp_setattr*/
+	0,			/*tp_compare*/
+	0,			/*tp_repr*/
+	0,			/*tp_as_number*/
+	0,			/*tp_as_sequence*/
+	0,			/*tp_as_mapping*/
+	0,			/*tp_hash*/
+};
+
+/* -------------------------------------------------------*/
+
+static PyObject * 
+PyCurses_InitScr(self, args)
+     PyObject * self;
+     PyObject * args;
+{
+  static int already_inited = FALSE;
+  if (!PyArg_NoArgs(args))
+    return (PyObject *)NULL;
+  if (already_inited == TRUE) {
+    wrefresh(stdscr);
+    return (PyObject *)PyCursesWindow_New(stdscr);
+  }
+  already_inited = TRUE;
+  return (PyObject *)PyCursesWindow_New(initscr());
+}
+
+static PyObject * 
+PyCurses_EndWin(self, args)
+     PyObject * self;
+     PyObject * args;
+{
+  if (!PyArg_NoArgs(args))
+    return (PyObject *)NULL;
+  endwin();
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+
+static PyObject * 
+PyCurses_IsEndWin(self, args)
+     PyObject * self;
+     PyObject * args;
+{
+  if (!PyArg_NoArgs(args))
+    return (PyObject *)NULL;
+  if (isendwin() == FALSE) {
+    Py_INCREF(Py_False);
+    return Py_False;
+  }
+  Py_INCREF(Py_True);
+  return Py_True;
+}
+
+static PyObject *
+PyCurses_DoUpdate(self,arg)
+     PyObject * self;
+     PyObject * arg;
+{
+  if (!PyArg_NoArgs(arg))
+    return (PyObject *)NULL;
+  return (PyObject *)PyInt_FromLong(doupdate());
+}
+
+static PyObject *
+PyCurses_NewWindow(self,arg)
+     PyObject * self;
+     PyObject * arg;
+{
+  WINDOW *win;
+  int nlines, ncols, begin_y, begin_x;
+  nlines = 0;
+  ncols  = 0;
+  if (!PyArg_Parse(arg,
+		   "(iiii);nlines,ncols,begin_y,begin_x",
+		   &nlines,&ncols,&begin_y,&begin_x))
+    if (!PyArg_Parse(arg,"(ii)",&begin_y,&begin_x))
+      return (PyObject *)NULL;
+  win = newwin(nlines,ncols,begin_y,begin_x);
+  if (win == NULL) {
+    Py_INCREF(Py_None);
+    return (PyObject *)Py_None;
+  }
+  return (PyObject *)PyCursesWindow_New(win);
+}
+
+static PyObject *
+PyCurses_Beep(self,arg)
+     PyObject * self;
+     PyObject * arg;
+{
+  if (!PyArg_NoArgs(arg))
+    return (PyObject *)NULL;
+  beep();
+  Py_INCREF(Py_None);
+  return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCurses_Flash(self,arg)
+     PyObject * self;
+     PyObject * arg;
+{
+  if (!PyArg_NoArgs(arg))
+    return (PyObject *)NULL;
+  flash();
+  Py_INCREF(Py_None);
+  return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCurses_UngetCh(self,arg)
+     PyObject * self;
+     PyObject * arg;
+{
+  int ch;
+  if (!PyArg_Parse(arg,"i;integer",&ch))
+    return (PyObject *)NULL;
+  ungetch(ch);
+  Py_INCREF(Py_None);
+  return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCurses_FlushInp(self,arg)
+     PyObject * self;
+     PyObject * arg;
+{
+  if (!PyArg_NoArgs(arg))
+    return (PyObject *)NULL;
+  flushinp();
+  Py_INCREF(Py_None);
+  return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCurses_CBreak(self,arg)
+     PyObject * self;
+     PyObject * arg;
+{
+  if (!PyArg_NoArgs(arg))
+    return (PyObject *)NULL;
+  cbreak();
+  Py_INCREF(Py_None);
+  return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCurses_NoCBreak(self,arg)
+     PyObject * self;
+     PyObject * arg;
+{
+  if (!PyArg_NoArgs(arg))
+    return (PyObject *)NULL;
+  nocbreak();
+  Py_INCREF(Py_None);
+  return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCurses_Echo(self,arg)
+     PyObject * self;
+     PyObject * arg;
+{
+  if (!PyArg_NoArgs(arg))
+    return (PyObject *)NULL;
+  echo();
+  Py_INCREF(Py_None);
+  return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCurses_NoEcho(self,arg)
+     PyObject * self;
+     PyObject * arg;
+{
+  if (!PyArg_NoArgs(arg))
+    return (PyObject *)NULL;
+  noecho();
+  Py_INCREF(Py_None);
+  return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCurses_Nl(self,arg)
+     PyObject * self;
+     PyObject * arg;
+{
+  if (!PyArg_NoArgs(arg))
+    return (PyObject *)NULL;
+  nl();
+  Py_INCREF(Py_None);
+  return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCurses_NoNl(self,arg)
+     PyObject * self;
+     PyObject * arg;
+{
+  if (!PyArg_NoArgs(arg))
+    return (PyObject *)NULL;
+  nonl();
+  Py_INCREF(Py_None);
+  return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCurses_Raw(self,arg)
+     PyObject * self;
+     PyObject * arg;
+{
+  if (!PyArg_NoArgs(arg))
+    return (PyObject *)NULL;
+  raw();
+  Py_INCREF(Py_None);
+  return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCurses_NoRaw(self,arg)
+     PyObject * self;
+     PyObject * arg;
+{
+  if (!PyArg_NoArgs(arg))
+    return (PyObject *)NULL;
+  noraw();
+  Py_INCREF(Py_None);
+  return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCurses_IntrFlush(self,arg)
+     PyObject * self;
+     PyObject * arg;
+{
+  int ch;
+  if (!PyArg_Parse(arg,"i;True(1), False(0)",&ch))
+    return (PyObject *)NULL;
+  intrflush(NULL,ch);
+  Py_INCREF(Py_None);
+  return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCurses_Meta(self,arg)
+     PyObject * self;
+     PyObject * arg;
+{
+  int ch;
+  if (!PyArg_Parse(arg,"i;True(1), False(0)",&ch))
+    return (PyObject *)NULL;
+  meta(NULL,ch);
+  Py_INCREF(Py_None);
+  return (PyObject *)Py_None;
+}
+
+static PyObject *
+PyCurses_KeyName(self,arg)
+     PyObject * self;
+     PyObject * arg;
+{
+  int ch;
+  if (!PyArg_Parse(arg,"i",&ch))
+    return (PyObject *)NULL;
+  return PyString_FromString((char *)keyname(ch));
+}
+
+#ifdef NOT_YET
+static PyObject * 
+PyCurses_NewTerm(self, args)
+     PyObject * self;
+     PyObject * args;
+{
+}
+
+static PyObject * 
+PyCurses_SetTerm(self, args)
+     PyObject * self;
+     PyObject * args;
+{
+}
+#endif
+
+/* List of functions defined in the module */
+
+static PyMethodDef PyCurses_methods[] = {
+	{"initscr",             (PyCFunction)PyCurses_InitScr},
+	{"endwin",              (PyCFunction)PyCurses_EndWin},
+	{"isendwin",            (PyCFunction)PyCurses_IsEndWin},
+	{"doupdate",            (PyCFunction)PyCurses_DoUpdate},
+	{"newwin",              (PyCFunction)PyCurses_NewWindow},
+	{"beep",                (PyCFunction)PyCurses_Beep},
+	{"flash",               (PyCFunction)PyCurses_Flash},
+	{"ungetch",             (PyCFunction)PyCurses_UngetCh},
+	{"flushinp",            (PyCFunction)PyCurses_FlushInp},
+	{"cbreak",              (PyCFunction)PyCurses_CBreak},
+	{"nocbreak",            (PyCFunction)PyCurses_NoCBreak},
+	{"echo",                (PyCFunction)PyCurses_Echo},
+	{"noecho",              (PyCFunction)PyCurses_NoEcho},
+	{"nl",                  (PyCFunction)PyCurses_Nl},
+	{"nonl",                (PyCFunction)PyCurses_NoNl},
+	{"raw",                 (PyCFunction)PyCurses_Raw},
+	{"noraw",               (PyCFunction)PyCurses_NoRaw},
+	{"intrflush",           (PyCFunction)PyCurses_IntrFlush},
+	{"meta",                (PyCFunction)PyCurses_Meta},
+	{"keyname",             (PyCFunction)PyCurses_KeyName},
+#ifdef NOT_YET
+	{"newterm",             (PyCFunction)PyCurses_NewTerm},
+	{"set_term",            (PyCFunction)PyCurses_SetTerm},
+#endif
+	{NULL,		NULL}		/* sentinel */
+};
+
+/* Initialization function for the module */
+
+void
+initcurses()
+{
+	PyObject *m, *d, *x;
+
+	/* Create the module and add the functions */
+	m = Py_InitModule("ncurses", PyCurses_methods);
+
+	PyCurses_OK  = Py_True;
+	PyCurses_ERR = Py_False;
+	Py_INCREF(PyCurses_OK);
+	Py_INCREF(PyCurses_ERR);
+	/* Add some symbolic constants to the module */
+	d = PyModule_GetDict(m);
+	/* Here are some defines */
+	PyDict_SetItemString(d,"OK", PyCurses_OK);
+	PyDict_SetItemString(d,"ERR",PyCurses_ERR);
+
+#define SetDictChar(string,ch) \
+	PyDict_SetItemString(d,string,PyInt_FromLong(ch));
+ 
+	/* Here are some graphic symbols you can use */
+        SetDictChar("ACS_ULCORNER",(ACS_ULCORNER));
+	SetDictChar("ACS_ULCORNER",(ACS_ULCORNER));
+	SetDictChar("ACS_LLCORNER",(ACS_LLCORNER));
+	SetDictChar("ACS_URCORNER",(ACS_URCORNER));
+	SetDictChar("ACS_LRCORNER",(ACS_LRCORNER));
+	SetDictChar("ACS_RTEE",    (ACS_RTEE));
+	SetDictChar("ACS_LTEE",    (ACS_LTEE));
+	SetDictChar("ACS_BTEE",    (ACS_BTEE));
+	SetDictChar("ACS_TTEE",    (ACS_TTEE));
+	SetDictChar("ACS_HLINE",   (ACS_HLINE));
+	SetDictChar("ACS_VLINE",   (ACS_VLINE));
+	SetDictChar("ACS_PLUS",    (ACS_PLUS));
+	SetDictChar("ACS_S1",      (ACS_S1));
+	SetDictChar("ACS_S9",      (ACS_S9));
+	SetDictChar("ACS_DIAMOND", (ACS_DIAMOND));
+	SetDictChar("ACS_CKBOARD", (ACS_CKBOARD));
+	SetDictChar("ACS_DEGREE",  (ACS_DEGREE));
+	SetDictChar("ACS_PLMINUS", (ACS_PLMINUS));
+	SetDictChar("ACS_BULLET",  (ACS_BULLET));
+	SetDictChar("ACS_LARROW",  (ACS_RARROW));
+	SetDictChar("ACS_DARROW",  (ACS_DARROW));
+	SetDictChar("ACS_UARROW",  (ACS_UARROW));
+	SetDictChar("ACS_BOARD",   (ACS_BOARD));
+	SetDictChar("ACS_LANTERN", (ACS_LANTERN));
+	SetDictChar("ACS_BLOCK",   (ACS_BLOCK));
+
+	/* Here are some attributes you can add to chars to print */
+	PyDict_SetItemString(d, "A_NORMAL",    PyInt_FromLong(A_NORMAL));
+	PyDict_SetItemString(d, "A_STANDOUT",  PyInt_FromLong(A_STANDOUT));
+	PyDict_SetItemString(d, "A_UNDERLINE", PyInt_FromLong(A_UNDERLINE));
+	PyDict_SetItemString(d, "A_REVERSE",   PyInt_FromLong(A_REVERSE));
+	PyDict_SetItemString(d, "A_BLINK",     PyInt_FromLong(A_BLINK));
+	PyDict_SetItemString(d, "A_DIM",       PyInt_FromLong(A_DIM));
+	PyDict_SetItemString(d, "A_BOLD",      PyInt_FromLong(A_BOLD));
+	PyDict_SetItemString(d, "A_ALTCHARSET",PyInt_FromLong(A_ALTCHARSET));
+
+	/* Now set everything up for KEY_ variables */
+	{
+	  int key;
+	  char *key_n;
+	  char *key_n2;
+	  for (key=KEY_MIN;key < KEY_MAX; key++) {
+	    key_n = (char *)keyname(key);
+	    if (strcmp(key_n,"UNKNOWN KEY")==0)
+	      continue;
+	    if (strncmp(key_n,"KEY_F(",6)==0) {
+	      char *p1, *p2;
+	      key_n2 = malloc(strlen(key_n)+1);
+	      p1 = key_n;
+	      p2 = key_n2;
+	      while (*p1) {
+		if (*p1 != '(' && *p1 != ')') {
+		  *p2 = *p1;
+		  p2++;
+		}
+		p1++;
+	      }
+	      *p2 = (char)0;
+	    } else
+	      key_n2 = key_n;
+	    PyDict_SetItemString(d,key_n2,PyInt_FromLong(key));
+	    if (key_n2 != key_n)
+	      free(key_n2);
+	  }
+	SetDictChar("KEY_MIN",KEY_MIN);
+	SetDictChar("KEY_MAX",KEY_MAX);
+	}
+
+	/* Check for errors */
+	if (PyErr_Occurred())
+		Py_FatalError("can't initialize module syslog");
+}