summaryrefslogtreecommitdiffstats
path: root/Modules/_cursesmodule.c
diff options
context:
space:
mode:
Diffstat (limited to 'Modules/_cursesmodule.c')
-rw-r--r--Modules/_cursesmodule.c1298
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");
+}
generated by cgit v0.12 at 2024-11-27 13:22:40 (GMT)