char *PyCursesVersion = "2.2";

#include "Python.h"

#ifdef __osf__

#define STRICT_SYSV_CURSES /* Don't use ncurses extensions */

#ifdef __hpux

#define STRICT_SYSV_CURSES

#define CURSES_MODULE

#include "py_curses.h"

extern int setupterm(char *,int,int *);

#ifdef __sgi

#include <term.h>

#if !defined(HAVE_NCURSES_H) && (defined(sgi) || defined(__sun) || defined(SCO5))

#define STRICT_SYSV_CURSES /* Don't use ncurses extensions */

typedef chtype attr_t; /* No attr_t type is available */

#if defined(_AIX)

#define STRICT_SYSV_CURSES

static PyObject *PyCursesError;

static int initialised_setupterm = FALSE;

static int initialised = FALSE;

static int initialisedcolors = FALSE;

#define PyCursesSetupTermCalled \

#define PyCursesInitialised \

#define PyCursesInitialisedColor \

#ifndef MIN

#define MIN(x,y) ((x) < (y) ? (x) : (y))

static PyObject *

PyCursesCheckERR(int code, char *fname)

{

if (code != ERR) {

Py_INCREF(Py_None);

return Py_None;

} else {

if (fname == NULL) {

PyErr_SetString(PyCursesError, catchall_ERR);

} else {

PyErr_Format(PyCursesError, "%s() returned ERR", fname);

}

return NULL;

}

}

static int

PyCurses_ConvertToChtype(PyObject *obj, chtype *ch)

{

if (PyInt_Check(obj)) {

*ch = (chtype) PyInt_AsLong(obj);

} else if(PyString_Check(obj)

&& (PyString_Size(obj) == 1)) {

*ch = (chtype) *PyString_AsString(obj);

} else {

return 0;

}

return 1;

}

static int func_PyCursesSetupTermCalled(void)

{

PyCursesSetupTermCalled;

return 1;

}

static int func_PyCursesInitialised(void)

{

PyCursesInitialised;

return 1;

}

static int func_PyCursesInitialisedColor(void)

{

PyCursesInitialisedColor;

return 1;

}

PyTypeObject PyCursesWindow_Type;

#define Window_NoArgNoReturnFunction(X) \

static PyObject *PyCursesWindow_ ## X (PyCursesWindowObject *self, PyObject *args) \

{ return PyCursesCheckERR(X(self->win), # X); }

#define Window_NoArgTrueFalseFunction(X) \

static PyObject * PyCursesWindow_ ## X (PyCursesWindowObject *self) \

{ \

if (X (self->win) == FALSE) { Py_INCREF(Py_False); return Py_False; } \

else { Py_INCREF(Py_True); return Py_True; } }

#define Window_NoArgNoReturnVoidFunction(X) \

static PyObject * PyCursesWindow_ ## X (PyCursesWindowObject *self) \

{ \

X(self->win); Py_INCREF(Py_None); return Py_None; }

#define Window_NoArg2TupleReturnFunction(X, TYPE, ERGSTR) \

static PyObject * PyCursesWindow_ ## X (PyCursesWindowObject *self) \

{ \

TYPE arg1, arg2; \

X(self->win,arg1,arg2); return Py_BuildValue(ERGSTR, arg1, arg2); }

#define Window_OneArgNoReturnVoidFunction(X, TYPE, PARSESTR) \

static PyObject * PyCursesWindow_ ## X (PyCursesWindowObject *self, PyObject *args) \

{ \

TYPE arg1; \

if (!PyArg_ParseTuple(args, PARSESTR, &arg1)) return NULL; \

X(self->win,arg1); Py_INCREF(Py_None); return Py_None; }

#define Window_OneArgNoReturnFunction(X, TYPE, PARSESTR) \

static PyObject * PyCursesWindow_ ## X (PyCursesWindowObject *self, PyObject *args) \

{ \

TYPE arg1; \

if (!PyArg_ParseTuple(args,PARSESTR, &arg1)) return NULL; \

return PyCursesCheckERR(X(self->win, arg1), # X); }

#define Window_TwoArgNoReturnFunction(X, TYPE, PARSESTR) \

static PyObject * PyCursesWindow_ ## X (PyCursesWindowObject *self, PyObject *args) \

{ \

TYPE arg1, arg2; \

if (!PyArg_ParseTuple(args,PARSESTR, &arg1, &arg2)) return NULL; \

return PyCursesCheckERR(X(self->win, arg1, arg2), # X); }

Window_NoArgNoReturnFunction(untouchwin)

Window_NoArgNoReturnFunction(touchwin)

Window_NoArgNoReturnFunction(redrawwin)

Window_NoArgNoReturnFunction(winsertln)

Window_NoArgNoReturnFunction(werase)

Window_NoArgNoReturnFunction(wdeleteln)

Window_NoArgTrueFalseFunction(is_wintouched)

Window_NoArgNoReturnVoidFunction(wsyncup)

Window_NoArgNoReturnVoidFunction(wsyncdown)

Window_NoArgNoReturnVoidFunction(wstandend)

Window_NoArgNoReturnVoidFunction(wstandout)

Window_NoArgNoReturnVoidFunction(wcursyncup)

Window_NoArgNoReturnVoidFunction(wclrtoeol)

Window_NoArgNoReturnVoidFunction(wclrtobot)

Window_NoArgNoReturnVoidFunction(wclear)

Window_OneArgNoReturnVoidFunction(idcok, int, "i;True(1) or False(0)")

Window_OneArgNoReturnVoidFunction(immedok, int, "i;True(1) or False(0)")

Window_OneArgNoReturnVoidFunction(wtimeout, int, "i;delay")

Window_NoArg2TupleReturnFunction(getyx, int, "ii")

Window_NoArg2TupleReturnFunction(getbegyx, int, "ii")

Window_NoArg2TupleReturnFunction(getmaxyx, int, "ii")

Window_NoArg2TupleReturnFunction(getparyx, int, "ii")

Window_OneArgNoReturnFunction(clearok, int, "i;True(1) or False(0)")

Window_OneArgNoReturnFunction(idlok, int, "i;True(1) or False(0)")

#if defined(__NetBSD__)

Window_OneArgNoReturnVoidFunction(keypad, int, "i;True(1) or False(0)")

Window_OneArgNoReturnFunction(keypad, int, "i;True(1) or False(0)")

Window_OneArgNoReturnFunction(leaveok, int, "i;True(1) or False(0)")

#if defined(__NetBSD__)

Window_OneArgNoReturnVoidFunction(nodelay, int, "i;True(1) or False(0)")

Window_OneArgNoReturnFunction(nodelay, int, "i;True(1) or False(0)")

Window_OneArgNoReturnFunction(notimeout, int, "i;True(1) or False(0)")

Window_OneArgNoReturnFunction(scrollok, int, "i;True(1) or False(0)")

Window_OneArgNoReturnFunction(winsdelln, int, "i;nlines")

Window_OneArgNoReturnFunction(syncok, int, "i;True(1) or False(0)")

Window_TwoArgNoReturnFunction(mvwin, int, "ii;y,x")

Window_TwoArgNoReturnFunction(mvderwin, int, "ii;y,x")

Window_TwoArgNoReturnFunction(wmove, int, "ii;y,x")

#ifndef STRICT_SYSV_CURSES

Window_TwoArgNoReturnFunction(wresize, int, "ii;lines,columns")

static PyObject *

PyCursesWindow_New(WINDOW *win)

{

PyCursesWindowObject *wo;

wo = PyObject_NEW(PyCursesWindowObject, &PyCursesWindow_Type);

if (wo == NULL) return NULL;

wo->win = win;

return (PyObject *)wo;

}

static void

PyCursesWindow_Dealloc(PyCursesWindowObject *wo)

{

if (wo->win != stdscr) delwin(wo->win);

PyObject_DEL(wo);

}

static PyObject *

PyCursesWindow_AddCh(PyCursesWindowObject *self, PyObject *args)

{

int rtn, x, y, use_xy = FALSE;

PyObject *temp;

chtype ch = 0;

attr_t attr = A_NORMAL;

long lattr;

switch (PyTuple_Size(args)) {

case 1:

if (!PyArg_ParseTuple(args, "O;ch or int", &temp))

return NULL;

break;

case 2:

if (!PyArg_ParseTuple(args, "Ol;ch or int,attr", &temp, &lattr))

return NULL;

attr = lattr;

break;

case 3:

if (!PyArg_ParseTuple(args,"iiO;y,x,ch or int", &y, &x, &temp))

return NULL;

use_xy = TRUE;

break;

case 4:

if (!PyArg_ParseTuple(args,"iiOl;y,x,ch or int, attr",

&y, &x, &temp, &lattr))

return NULL;

attr = lattr;

use_xy = TRUE;

break;

default:

PyErr_SetString(PyExc_TypeError, "addch requires 1 to 4 arguments");

return NULL;

}

if (!PyCurses_ConvertToChtype(temp, &ch)) {

PyErr_SetString(PyExc_TypeError, "argument 1 or 3 must be a ch or an int");

return NULL;

}

if (use_xy == TRUE)

rtn = mvwaddch(self->win,y,x, ch | attr);

else {

rtn = waddch(self->win, ch | attr);

}

return PyCursesCheckERR(rtn, "addch");

}

static PyObject *

PyCursesWindow_AddStr(PyCursesWindowObject *self, PyObject *args)

{

int rtn;

int x, y;

char *str;

attr_t attr = A_NORMAL , attr_old = A_NORMAL;

long lattr;

int use_xy = FALSE, use_attr = FALSE;

switch (PyTuple_Size(args)) {

case 1:

if (!PyArg_ParseTuple(args,"s;str", &str))

return NULL;

break;

case 2:

if (!PyArg_ParseTuple(args,"sl;str,attr", &str, &lattr))

return NULL;

attr = lattr;

use_attr = TRUE;

break;

case 3:

if (!PyArg_ParseTuple(args,"iis;int,int,str", &y, &x, &str))

return NULL;

use_xy = TRUE;

break;

case 4:

if (!PyArg_ParseTuple(args,"iisl;int,int,str,attr", &y, &x, &str, &lattr))

return NULL;

attr = lattr;

use_xy = use_attr = TRUE;

break;

default:

PyErr_SetString(PyExc_TypeError, "addstr requires 1 to 4 arguments");

return 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);

return PyCursesCheckERR(rtn, "addstr");

}

static PyObject *

PyCursesWindow_AddNStr(PyCursesWindowObject *self, PyObject *args)

{

int rtn, x, y, n;

char *str;

attr_t attr = A_NORMAL , attr_old = A_NORMAL;

long lattr;

int use_xy = FALSE, use_attr = FALSE;

switch (PyTuple_Size(args)) {

case 2:

if (!PyArg_ParseTuple(args,"si;str,n", &str, &n))

return NULL;

break;

case 3:

if (!PyArg_ParseTuple(args,"sil;str,n,attr", &str, &n, &lattr))

return NULL;

attr = lattr;

use_attr = TRUE;

break;

case 4:

if (!PyArg_ParseTuple(args,"iisi;y,x,str,n", &y, &x, &str, &n))

return NULL;

use_xy = TRUE;

break;

case 5:

if (!PyArg_ParseTuple(args,"iisil;y,x,str,n,attr", &y, &x, &str, &n, &lattr))

return NULL;

attr = lattr;

use_xy = use_attr = TRUE;

break;

default:

PyErr_SetString(PyExc_TypeError, "addnstr requires 2 to 5 arguments");

return NULL;

}

if (use_attr == TRUE) {

attr_old = getattrs(self->win);

wattrset(self->win,attr);

}

if (use_xy == TRUE)

rtn = mvwaddnstr(self->win,y,x,str,n);

else

rtn = waddnstr(self->win,str,n);

if (use_attr == TRUE)

wattrset(self->win,attr_old);

return PyCursesCheckERR(rtn, "addnstr");

}

static PyObject *

PyCursesWindow_Bkgd(PyCursesWindowObject *self, PyObject *args)

{

PyObject *temp;

chtype bkgd;

attr_t attr = A_NORMAL;

long lattr;

switch (PyTuple_Size(args)) {

case 1:

if (!PyArg_ParseTuple(args, "O;ch or int", &temp))

return NULL;

break;

case 2:

if (!PyArg_ParseTuple(args,"Ol;ch or int,attr", &temp, &lattr))

return NULL;

attr = lattr;

break;

default:

PyErr_SetString(PyExc_TypeError, "bkgd requires 1 or 2 arguments");

return NULL;

}

if (!PyCurses_ConvertToChtype(temp, &bkgd)) {

PyErr_SetString(PyExc_TypeError, "argument 1 or 3 must be a ch or an int");

return NULL;

}

return PyCursesCheckERR(wbkgd(self->win, bkgd | attr), "bkgd");

}

static PyObject *

PyCursesWindow_AttrOff(PyCursesWindowObject *self, PyObject *args)

{

long lattr;

if (!PyArg_ParseTuple(args,"l;attr", &lattr))

return NULL;

return PyCursesCheckERR(wattroff(self->win, (attr_t)lattr), "attroff");

}

static PyObject *

PyCursesWindow_AttrOn(PyCursesWindowObject *self, PyObject *args)

{

long lattr;

if (!PyArg_ParseTuple(args,"l;attr", &lattr))

return NULL;

return PyCursesCheckERR(wattron(self->win, (attr_t)lattr), "attron");

}

static PyObject *

PyCursesWindow_AttrSet(PyCursesWindowObject *self, PyObject *args)

{

long lattr;

if (!PyArg_ParseTuple(args,"l;attr", &lattr))

return NULL;

return PyCursesCheckERR(wattrset(self->win, (attr_t)lattr), "attrset");

}

static PyObject *

PyCursesWindow_BkgdSet(PyCursesWindowObject *self, PyObject *args)

{

PyObject *temp;

chtype bkgd;

attr_t attr = A_NORMAL;

long lattr;

switch (PyTuple_Size(args)) {

case 1:

if (!PyArg_ParseTuple(args, "O;ch or int", &temp))

return NULL;

break;

case 2:

if (!PyArg_ParseTuple(args,"Ol;ch or int,attr", &temp, &lattr))

return NULL;

attr = lattr;

break;

default:

PyErr_SetString(PyExc_TypeError, "bkgdset requires 1 or 2 arguments");

return NULL;

}

if (!PyCurses_ConvertToChtype(temp, &bkgd)) {

PyErr_SetString(PyExc_TypeError, "argument 1 must be a ch or an int");

return NULL;

}

wbkgdset(self->win, bkgd | attr);

return PyCursesCheckERR(0, "bkgdset");

}

static PyObject *

PyCursesWindow_Border(PyCursesWindowObject *self, PyObject *args)

{

PyObject *temp[8];

chtype ch[8];

int i;

/* Clear the array of parameters */

for(i=0; i<8; i++) {

temp[i] = NULL;

ch[i] = 0;

}

if (!PyArg_ParseTuple(args,"|OOOOOOOO;ls,rs,ts,bs,tl,tr,bl,br",

&temp[0], &temp[1], &temp[2], &temp[3],

&temp[4], &temp[5], &temp[6], &temp[7]))

return NULL;

for(i=0; i<8; i++) {

if (temp[i] != NULL && !PyCurses_ConvertToChtype(temp[i], &ch[i])) {

PyErr_Format(PyExc_TypeError,

"argument %i must be a ch or an int", i+1);

return NULL;

}

}

wborder(self->win,

ch[0], ch[1], ch[2], ch[3],

ch[4], ch[5], ch[6], ch[7]);

Py_INCREF(Py_None);

return Py_None;

}

static PyObject *

PyCursesWindow_Box(PyCursesWindowObject *self, PyObject *args)

{

chtype ch1=0,ch2=0;

switch(PyTuple_Size(args)){

case 0: break;

default:

if (!PyArg_ParseTuple(args,"ll;vertint,horint", &ch1, &ch2))

return NULL;

}

box(self->win,ch1,ch2);

Py_INCREF(Py_None);

return Py_None;

}

#if defined(HAVE_NCURSES_H) || defined(MVWDELCH_IS_EXPRESSION)

#define py_mvwdelch mvwdelch

int py_mvwdelch(WINDOW *w, int y, int x)

{

mvwdelch(w,y,x);

/* On HP/UX, mvwdelch already returns. On other systems,

return 0;

}

static PyObject *

PyCursesWindow_ChgAt(PyCursesWindowObject *self, PyObject *args)

{

int rtn;

int x, y;

int num = -1;

short color;

attr_t attr = A_NORMAL;

long lattr;

int use_xy = FALSE;

switch (PyTuple_Size(args)) {

case 1:

if (!PyArg_ParseTuple(args,"l;attr", &lattr))

return NULL;

attr = lattr;

break;

case 2:

if (!PyArg_ParseTuple(args,"il;n,attr", &num, &lattr))

return NULL;

attr = lattr;

break;

case 3:

if (!PyArg_ParseTuple(args,"iil;int,int,attr", &y, &x, &lattr))

return NULL;

attr = lattr;

use_xy = TRUE;

break;

case 4:

if (!PyArg_ParseTuple(args,"iiil;int,int,n,attr", &y, &x, &num, &lattr))

return NULL;

attr = lattr;

use_xy = TRUE;

break;

default:

PyErr_SetString(PyExc_TypeError, "chgat requires 1 to 4 arguments");

return NULL;

}

color = (short)((attr >> 8) & 0xff);

attr = attr - (color << 8);

if (use_xy == TRUE) {

rtn = mvwchgat(self->win,y,x,num,attr,color,NULL);

touchline(self->win,y,1);

} else {

getyx(self->win,y,x);

rtn = wchgat(self->win,num,attr,color,NULL);

touchline(self->win,y,1);

}

return PyCursesCheckERR(rtn, "chgat");

}

static PyObject *

PyCursesWindow_DelCh(PyCursesWindowObject *self, PyObject *args)

{

int rtn;

int x, y;

switch (PyTuple_Size(args)) {

case 0:

rtn = wdelch(self->win);

break;

case 2:

if (!PyArg_ParseTuple(args,"ii;y,x", &y, &x))

return NULL;

rtn = py_mvwdelch(self->win,y,x);

break;

default:

PyErr_SetString(PyExc_TypeError, "delch requires 0 or 2 arguments");

return NULL;

}

return PyCursesCheckERR(rtn, "[mv]wdelch");

}

static PyObject *

PyCursesWindow_DerWin(PyCursesWindowObject *self, PyObject *args)

{

WINDOW *win;

int nlines, ncols, begin_y, begin_x;

nlines = 0;

ncols = 0;

switch (PyTuple_Size(args)) {

case 2:

if (!PyArg_ParseTuple(args,"ii;begin_y,begin_x",&begin_y,&begin_x))

return NULL;

break;

case 4:

if (!PyArg_ParseTuple(args, "iiii;nlines,ncols,begin_y,begin_x",

&nlines,&ncols,&begin_y,&begin_x))

return NULL;

break;

default:

PyErr_SetString(PyExc_TypeError, "derwin requires 2 or 4 arguments");

return NULL;

}

win = derwin(self->win,nlines,ncols,begin_y,begin_x);

if (win == NULL) {

PyErr_SetString(PyCursesError, catchall_NULL);

return NULL;

}

return (PyObject *)PyCursesWindow_New(win);

}

static PyObject *

PyCursesWindow_EchoChar(PyCursesWindowObject *self, PyObject *args)

{

PyObject *temp;

chtype ch;

attr_t attr = A_NORMAL;

long lattr;

switch (PyTuple_Size(args)) {

case 1:

if (!PyArg_ParseTuple(args,"O;ch or int", &temp))

return NULL;

break;

case 2:

if (!PyArg_ParseTuple(args,"Ol;ch or int,attr", &temp, &lattr))

return NULL;

attr = lattr;

break;

default:

PyErr_SetString(PyExc_TypeError, "echochar requires 1 or 2 arguments");

return NULL;

}

if (!PyCurses_ConvertToChtype(temp, &ch)) {

PyErr_SetString(PyExc_TypeError, "argument 1 must be a ch or an int");

return NULL;

}

#ifdef WINDOW_HAS_FLAGS

if (self->win->_flags & _ISPAD)

return PyCursesCheckERR(pechochar(self->win, ch | attr),

"echochar");

else

return PyCursesCheckERR(wechochar(self->win, ch | attr),

"echochar");

}

#ifdef NCURSES_MOUSE_VERSION

static PyObject *

PyCursesWindow_Enclose(PyCursesWindowObject *self, PyObject *args)

{

int x, y;

if (!PyArg_ParseTuple(args,"ii;y,x", &y, &x))

return NULL;

return PyInt_FromLong( wenclose(self->win,y,x) );

}

static PyObject *

PyCursesWindow_GetBkgd(PyCursesWindowObject *self)

{

return PyInt_FromLong((long) getbkgd(self->win));

}

static PyObject *

PyCursesWindow_GetCh(PyCursesWindowObject *self, PyObject *args)

{

int x, y;

int rtn;

switch (PyTuple_Size(args)) {

case 0:

Py_BEGIN_ALLOW_THREADS

rtn = wgetch(self->win);

Py_END_ALLOW_THREADS

break;

case 2:

if (!PyArg_ParseTuple(args,"ii;y,x",&y,&x))

return NULL;

Py_BEGIN_ALLOW_THREADS

rtn = mvwgetch(self->win,y,x);

Py_END_ALLOW_THREADS

break;

default:

PyErr_SetString(PyExc_TypeError, "getch requires 0 or 2 arguments");

return NULL;

}

return PyInt_FromLong((long)rtn);

}

static PyObject *

PyCursesWindow_GetKey(PyCursesWindowObject *self, PyObject *args)

{

int x, y;

int rtn;

switch (PyTuple_Size(args)) {

case 0:

Py_BEGIN_ALLOW_THREADS

rtn = wgetch(self->win);

Py_END_ALLOW_THREADS

break;

case 2:

if (!PyArg_ParseTuple(args,"ii;y,x",&y,&x))

return NULL;

Py_BEGIN_ALLOW_THREADS

rtn = mvwgetch(self->win,y,x);

Py_END_ALLOW_THREADS

break;

default:

PyErr_SetString(PyExc_TypeError, "getkey requires 0 or 2 arguments");

return NULL;

}

if (rtn == ERR) {

/* getch() returns ERR in nodelay mode */

PyErr_SetString(PyCursesError, "no input");

return NULL;

} else if (rtn<=255)

return Py_BuildValue("c", rtn);

else

#if defined(__NetBSD__)

return PyString_FromString(unctrl(rtn));

return PyString_FromString((char *)keyname(rtn));

}

static PyObject *

PyCursesWindow_GetStr(PyCursesWindowObject *self, PyObject *args)

{

int x, y, n;

char rtn[1024]; /* This should be big enough.. I hope */

int rtn2;

switch (PyTuple_Size(args)) {

case 0:

Py_BEGIN_ALLOW_THREADS

rtn2 = wgetnstr(self->win,rtn, 1023);

Py_END_ALLOW_THREADS

break;

case 1:

if (!PyArg_ParseTuple(args,"i;n", &n))

return NULL;

Py_BEGIN_ALLOW_THREADS

rtn2 = wgetnstr(self->win,rtn,MIN(n, 1023));

Py_END_ALLOW_THREADS

break;

case 2:

if (!PyArg_ParseTuple(args,"ii;y,x",&y,&x))

return NULL;

Py_BEGIN_ALLOW_THREADS

#ifdef STRICT_SYSV_CURSES

rtn2 = wmove(self->win,y,x)==ERR ? ERR : wgetnstr(self->win, rtn, 1023);

rtn2 = mvwgetnstr(self->win,y,x,rtn, 1023);

Py_END_ALLOW_THREADS

break;

case 3:

if (!PyArg_ParseTuple(args,"iii;y,x,n", &y, &x, &n))

return NULL;

#ifdef STRICT_SYSV_CURSES

Py_BEGIN_ALLOW_THREADS

rtn2 = wmove(self->win,y,x)==ERR ? ERR :

wgetnstr(self->win, rtn, MIN(n, 1023));

Py_END_ALLOW_THREADS

Py_BEGIN_ALLOW_THREADS

rtn2 = mvwgetnstr(self->win, y, x, rtn, MIN(n, 1023));

Py_END_ALLOW_THREADS

break;

default:

PyErr_SetString(PyExc_TypeError, "getstr requires 0 to 3 arguments");

return NULL;

}

if (rtn2 == ERR)

rtn[0] = 0;

return PyString_FromString(rtn);

}

static PyObject *

PyCursesWindow_Hline(PyCursesWindowObject *self, PyObject *args)

{

PyObject *temp;

chtype ch;

int n, x, y, code = OK;

attr_t attr = A_NORMAL;

long lattr;

switch (PyTuple_Size(args)) {

case 2:

if (!PyArg_ParseTuple(args, "Oi;ch or int,n", &temp, &n))

return NULL;

break;

case 3:

if (!PyArg_ParseTuple(args, "Oil;ch or int,n,attr", &temp, &n, &lattr))

return NULL;

attr = lattr;

break;

case 4:

if (!PyArg_ParseTuple(args, "iiOi;y,x,ch or int,n", &y, &x, &temp, &n))

return NULL;

code = wmove(self->win, y, x);

break;

case 5:

if (!PyArg_ParseTuple(args, "iiOil; y,x,ch or int,n,attr",

&y, &x, &temp, &n, &lattr))

return NULL;

attr = lattr;

code = wmove(self->win, y, x);

break;

default:

PyErr_SetString(PyExc_TypeError, "hline requires 2 to 5 arguments");

return NULL;

}

if (code != ERR) {

if (!PyCurses_ConvertToChtype(temp, &ch)) {

PyErr_SetString(PyExc_TypeError,

"argument 1 or 3 must be a ch or an int");

return NULL;

}

return PyCursesCheckERR(whline(self->win, ch | attr, n), "hline");

} else

return PyCursesCheckERR(code, "wmove");

}

static PyObject *

PyCursesWindow_InsCh(PyCursesWindowObject *self, PyObject *args)

{

int rtn, x, y, use_xy = FALSE;

PyObject *temp;