mirror of
https://github.com/python/cpython.git
synced 2024-12-05 07:43:50 +08:00
1456 lines
37 KiB
C
1456 lines
37 KiB
C
/***********************************************************
|
|
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.
|
|
|
|
******************************************************************/
|
|
|
|
/******************************************************************
|
|
This is a curses implementation. I have tried to be as complete
|
|
as possible. If there are functions you need that are not included,
|
|
please let me know and/or send me some diffs.
|
|
|
|
There are 3 basic types exported by this module:
|
|
1) Screen - This is not currently used
|
|
2) Window - This is the basic type. This is equivalent to "WINDOW *".
|
|
3) Pad - This is similar to Window, but works with Pads as defined
|
|
in curses.
|
|
|
|
Most of the routines can be looked up using the curses man page.
|
|
|
|
Here is a list of the currently supported methods and attributes
|
|
in the curses module:
|
|
|
|
Return Value Func/Attr Description
|
|
--------------------------------------------------------------------------
|
|
StringObject __version__ This returns a string representing
|
|
the current version of this module
|
|
WindowObject initscr() This initializes the screen for use
|
|
None endwin() Closes down the screen and returns
|
|
things as they were before calling
|
|
initscr()
|
|
True/FalseObject isendwin() Has endwin() been called?
|
|
IntObject doupdate() Updates screen and returns number
|
|
of bytes written to screen
|
|
WindowObject newwin(nlines,ncols,begin_y,begin_x)
|
|
newwin(begin_y,begin_x)
|
|
newwin() creates and returns
|
|
a new window.
|
|
None beep() Beep the screen if possible
|
|
None flash() Flash the screen if possible
|
|
None ungetch(int) Push the int back so next getch()
|
|
will return it.
|
|
Note: argument is an INT, not a CHAR
|
|
None flushinp() Flush all input buffers
|
|
None cbreak() Enter cbreak mode
|
|
None nocbreak() Leave cbreak mode
|
|
None echo() Enter echo mode
|
|
None noecho() Leave echo mode
|
|
None nl() Enter nl mode
|
|
None nonl() Leave nl mode
|
|
None raw() Enter raw mode
|
|
None noraw() Leave raw mode
|
|
None intrflush(int) Set or reset interruptable flush
|
|
mode, int=1 if set, 0 if notset.
|
|
None meta(int) Allow 8 bit or 7 bit chars.
|
|
int=1 is 8 bit, int=0 is 7 bit
|
|
StringObject keyname(int) return the text representation
|
|
of a KEY_ value. (see below)
|
|
|
|
Here is a list of the currently supported methods and attributes
|
|
in the WindowObject:
|
|
|
|
Return Value Func/Attr Description
|
|
--------------------------------------------------------------------------
|
|
IntObject refresh() Do refresh
|
|
IntObject nooutrefresh() Mark for refresh but wait
|
|
True/False mvwin(new_y,new_x) Move Window
|
|
True/False move(new_y,new_x) Move Cursor
|
|
WindowObject subwin(nlines,ncols,begin_y,begin_x)
|
|
subwin(begin_y,begin_x)
|
|
True/False addch(y,x,ch,attr)
|
|
addch(y,x,ch)
|
|
addch(ch,attr)
|
|
addch(ch)
|
|
True/False insch(y,x,ch,attr)
|
|
insch(y,x,ch)
|
|
insch(ch,attr)
|
|
insch(ch)
|
|
True/False delch(y,x)
|
|
delch()
|
|
True/False echochar(ch,attr)
|
|
echochar(ch)
|
|
True/False addstr(y,x,str,attr)
|
|
addstr(y,x,str)
|
|
addstr(str,attr)
|
|
addstr(str)
|
|
True/False attron(attr)
|
|
True/False attroff(attr)
|
|
True/False attrset(sttr)
|
|
True/False standend()
|
|
True/False standout()
|
|
True/False box(vertch,horch) vertch and horch are INTS
|
|
box()
|
|
None erase()
|
|
None deleteln()
|
|
None insertln()
|
|
(y,x) getyx()
|
|
(y,x) getbegyx()
|
|
(y,x) getmaxyx()
|
|
None clear()
|
|
None clrtobot()
|
|
None clrtoeol()
|
|
None scroll()
|
|
None touchwin()
|
|
None touchline(start,count)
|
|
IntObject getch(y,x)
|
|
getch()
|
|
StringObject getstr(y,x)
|
|
getstr()
|
|
IntObject inch(y,x)
|
|
inch()
|
|
None clearok(int) int=0 or int=1
|
|
None idlok(int) int=0 or int=1
|
|
None leaveok(int) int=0 or int=1
|
|
None scrollok(int) int=0 or int=1
|
|
None setscrreg(top,bottom)
|
|
None nodelay(int) int=0 or int=1
|
|
None notimeout(int) int=0 or int=1
|
|
******************************************************************/
|
|
|
|
|
|
/* curses module */
|
|
|
|
#include "Python.h"
|
|
|
|
#include <curses.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;
|
|
|
|
/******************************************************************
|
|
|
|
Change Log:
|
|
|
|
Version 1.1: 94/08/31:
|
|
Minor fixes given by Guido.
|
|
Changed 'ncurses' to 'curses'
|
|
Changed '__version__' to 'version'
|
|
Added PyErr_Clear() where needed
|
|
Moved ACS_* attribute initialization to PyCurses_InitScr() to fix
|
|
crash on SGI
|
|
Version 1.0: 94/08/30:
|
|
This is the first release of this software.
|
|
Released to the Internet via python-list@cwi.nl
|
|
|
|
******************************************************************/
|
|
char *PyCursesVersion = "1.1";
|
|
|
|
/* ------------- 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))
|
|
PyErr_Clear();
|
|
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)) {
|
|
PyErr_Clear();
|
|
if (!PyArg_Parse(arg,"(iii);y,x,ch", &y, &x, &ch)) {
|
|
PyErr_Clear();
|
|
use_xy = FALSE;
|
|
if (!PyArg_Parse(arg,"(ii);ch,attr", &ch, &attr))
|
|
PyErr_Clear();
|
|
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)) {
|
|
PyErr_Clear();
|
|
if (!PyArg_Parse(arg,"(iii);y,x,ch", &y, &x, &ch)) {
|
|
PyErr_Clear();
|
|
use_xy = FALSE;
|
|
if (!PyArg_Parse(arg,"(ii);ch,attr", &ch, &attr))
|
|
PyErr_Clear();
|
|
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;
|
|
PyErr_Clear();
|
|
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)) {
|
|
PyErr_Clear();
|
|
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)) {
|
|
PyErr_Clear();
|
|
if (!PyArg_Parse(arg,"(iis);y,x,str", &y, &x, &str)) {
|
|
PyErr_Clear();
|
|
use_xy = FALSE;
|
|
if (!PyArg_Parse(arg,"(si);str,attr", &str, &attr))
|
|
PyErr_Clear();
|
|
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;
|
|
PyErr_Clear();
|
|
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;
|
|
PyErr_Clear();
|
|
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;
|
|
PyErr_Clear();
|
|
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 Py_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 *ModDict;
|
|
|
|
static PyObject *
|
|
PyCurses_InitScr(self, args)
|
|
PyObject * self;
|
|
PyObject * args;
|
|
{
|
|
static int already_inited = FALSE;
|
|
WINDOW *win;
|
|
if (!PyArg_NoArgs(args))
|
|
return (PyObject *)NULL;
|
|
if (already_inited == TRUE) {
|
|
wrefresh(stdscr);
|
|
return (PyObject *)PyCursesWindow_New(stdscr);
|
|
}
|
|
already_inited = TRUE;
|
|
|
|
win = initscr();
|
|
|
|
/* This was moved from initcurses() because core dumped on SGI */
|
|
#define SetDictChar(string,ch) \
|
|
PyDict_SetItemString(ModDict,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));
|
|
|
|
return (PyObject *)PyCursesWindow_New(win);
|
|
}
|
|
|
|
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))
|
|
PyErr_Clear();
|
|
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("curses", 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);
|
|
ModDict = d; /* For PyCurses_InitScr */
|
|
|
|
/* Make the version available */
|
|
PyDict_SetItemString(d,"version",
|
|
PyString_FromString(PyCursesVersion));
|
|
|
|
/* Here are some defines */
|
|
PyDict_SetItemString(d,"OK", PyCurses_OK);
|
|
PyDict_SetItemString(d,"ERR",PyCurses_ERR);
|
|
|
|
/* 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 (key_n == NULL || 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");
|
|
}
|