glmodule.c

/*
Input used to generate the Python module "glmodule.c".
The stub generator is a Python script called "cgen.py".

Each definition must be contained on one line:

<returntype> <name> <type> <arg> <type> <arg>

<returntype> can be: void, short, long (XXX maybe others?)

<type> can be: char, string, short, float, long, or double
 string indicates a null terminated string;
 if <type> is char and <arg> begins with a *, the * is stripped
 and <type> is changed into string

<arg> has the form <mode> or <mode>[<subscript>]
 where <mode> can be
 s: arg is sent
 r: arg is received (arg is a pointer)
 and <subscript> can be (N and I are numbers):
 N
 argI
 retval
 N*argI
 N*I
 N*retval
 In the case where the subscript consists of two parts
 separated by *, the first part is the width of the matrix, and
 the second part is the length of the matrix. This order is
 opposite from the order used in C to declare a two-dimensional
 matrix.
*/

/*
 * An attempt has been made to make this module switch threads on qread
 * calls. It is far from safe, though.
 */

#include<gl.h>
#include<device.h>

#ifdef__sgi
externintdevport();
externinttextwritemask();
externintpagewritemask();
externintgewrite();
externintgettp();
#endif

#include"Python.h"
#include"cgensupport.h"

/*
Some stubs are too complicated for the stub generator.
We can include manually written versions of them here.
A line starting with '%' gives the name of the function so the stub
generator can include it in the table of functions.
*/


staticPyObject*
gl_qread(PyObject*self, PyObject*args)
{
longretval;
shortarg1 ;
Py_BEGIN_ALLOW_THREADS
retval=qread( &arg1 );
Py_END_ALLOW_THREADS
 { PyObject*v=PyTuple_New( 2 );
if (v==NULL) returnNULL;
PyTuple_SetItem(v, 0, mknewlongobject(retval));
PyTuple_SetItem(v, 1, mknewshortobject(arg1));
returnv;
 }
}


/*
varray -- an array of v.. calls.
The argument is an array (maybe list or tuple) of points.
Each point must be a tuple or list of coordinates (x, y, z).
The points may be 2- or 3-dimensional but must all have the
same dimension. Float and int values may be mixed however.
The points are always converted to 3D double precision points
by assuming z=0.0 if necessary (as indicated in the man page),
and for each point v3d() is called.
*/


staticPyObject*
gl_varray(PyObject*self, PyObject*args)
{
PyObject*v, *w=NULL;
inti, n, width;
doublevec[3];
PyObject* (*getitem)(PyObject*, int);

if (!PyArg_GetObject(args, 1, 0, &v))
returnNULL;

if (PyList_Check(v)) {
n=PyList_Size(v);
getitem=PyList_GetItem;
 }
elseif (PyTuple_Check(v)) {
n=PyTuple_Size(v);
getitem=PyTuple_GetItem;
 }
else {
PyErr_BadArgument();
returnNULL;
 }

if (n==0) {
Py_INCREF(Py_None);
returnPy_None;
 }
if (n>0)
w= (*getitem)(v, 0);

width=0;
if (w==NULL) {
 }
elseif (PyList_Check(w)) {
width=PyList_Size(w);
 }
elseif (PyTuple_Check(w)) {
width=PyTuple_Size(w);
 }

switch (width) {
case2:
vec[2] =0.0;
/* Fall through */
case3:
break;
default:
PyErr_BadArgument();
returnNULL;
 }

for (i=0; i<n; i++) {
w= (*getitem)(v, i);
if (!PyArg_GetDoubleArray(w, 1, 0, width, vec))
returnNULL;
v3d(vec);
 }

Py_INCREF(Py_None);
returnPy_None;
}

/*
vnarray, nvarray -- an array of n3f and v3f calls.
The argument is an array (list or tuple) of pairs of points and normals.
Each pair is a tuple (NOT a list) of a point and a normal for that point.
Each point or normal must be a tuple (NOT a list) of coordinates (x, y, z).
Three coordinates must be given. Float and int values may be mixed.
For each pair, n3f() is called for the normal, and then v3f() is called
for the vector.

vnarray and nvarray differ only in the order of the vector and normal in
the pair: vnarray expects (v, n) while nvarray expects (n, v).
*/

staticPyObject*gen_nvarray(); /* Forward */


staticPyObject*
gl_nvarray(PyObject*self, PyObject*args)
{
returngen_nvarray(args, 0);
}


staticPyObject*
gl_vnarray(PyObject*self, PyObject*args)
{
returngen_nvarray(args, 1);
}

/* Generic, internal version of {nv,nv}array: inorm indicates the
 argument order, 0: normal first, 1: vector first. */

staticPyObject*
gen_nvarray(PyObject*args, intinorm)
{
PyObject*v, *w, *wnorm, *wvec;
inti, n;
floatnorm[3], vec[3];
PyObject* (*getitem)(PyObject*, int);

if (!PyArg_GetObject(args, 1, 0, &v))
returnNULL;

if (PyList_Check(v)) {
n=PyList_Size(v);
getitem=PyList_GetItem;
 }
elseif (PyTuple_Check(v)) {
n=PyTuple_Size(v);
getitem=PyTuple_GetItem;
 }
else {
PyErr_BadArgument();
returnNULL;
 }

for (i=0; i<n; i++) {
w= (*getitem)(v, i);
if (!PyTuple_Check(w) ||PyTuple_Size(w) !=2) {
PyErr_BadArgument();
returnNULL;
 }
wnorm=PyTuple_GetItem(w, inorm);
wvec=PyTuple_GetItem(w, 1-inorm);
if (!PyArg_GetFloatArray(wnorm, 1, 0, 3, norm) ||
 !PyArg_GetFloatArray(wvec, 1, 0, 3, vec))
returnNULL;
n3f(norm);
v3f(vec);
 }

Py_INCREF(Py_None);
returnPy_None;
}

/* nurbssurface(s_knots[], t_knots[], ctl[][], s_order, t_order, type).
 The dimensions of ctl[] are computed as follows:
 [len(s_knots) - s_order], [len(t_knots) - t_order]
*/


staticPyObject*
gl_nurbssurface(PyObject*self, PyObject*args)
{
longarg1 ;
double*arg2 ;
longarg3 ;
double*arg4 ;
double*arg5 ;
longarg6 ;
longarg7 ;
longarg8 ;
longncoords;
longs_byte_stride, t_byte_stride;
longs_nctl, t_nctl;
longs, t;
PyObject*v, *w, *pt;
double*pnext;
if (!PyArg_GetLongArraySize(args, 6, 0, &arg1))
returnNULL;
if ((arg2=PyMem_NEW(double, arg1 )) ==NULL) {
returnPyErr_NoMemory();
 }
if (!PyArg_GetDoubleArray(args, 6, 0, arg1 , arg2))
returnNULL;
if (!PyArg_GetLongArraySize(args, 6, 1, &arg3))
returnNULL;
if ((arg4=PyMem_NEW(double, arg3 )) ==NULL) {
returnPyErr_NoMemory();
 }
if (!PyArg_GetDoubleArray(args, 6, 1, arg3 , arg4))
returnNULL;
if (!PyArg_GetLong(args, 6, 3, &arg6))
returnNULL;
if (!PyArg_GetLong(args, 6, 4, &arg7))
returnNULL;
if (!PyArg_GetLong(args, 6, 5, &arg8))
returnNULL;
if (arg8==N_XYZ)
ncoords=3;
elseif (arg8==N_XYZW)
ncoords=4;
else {
PyErr_BadArgument();
returnNULL;
 }
s_nctl=arg1-arg6;
t_nctl=arg3-arg7;
if (!PyArg_GetObject(args, 6, 2, &v))
returnNULL;
if (!PyList_Check(v) ||PyList_Size(v) !=s_nctl) {
PyErr_BadArgument();
returnNULL;
 }
if ((arg5=PyMem_NEW(double, s_nctl*t_nctl*ncoords )) ==NULL) {
returnPyErr_NoMemory();
 }
pnext=arg5;
for (s=0; s<s_nctl; s++) {
w=PyList_GetItem(v, s);
if (w==NULL|| !PyList_Check(w) ||
PyList_Size(w) !=t_nctl) {
PyErr_BadArgument();
returnNULL;
 }
for (t=0; t<t_nctl; t++) {
pt=PyList_GetItem(w, t);
if (!PyArg_GetDoubleArray(pt, 1, 0, ncoords, pnext))
returnNULL;
pnext+=ncoords;
 }
 }
s_byte_stride=sizeof(double) *ncoords;
t_byte_stride=s_byte_stride*s_nctl;
nurbssurface( arg1 , arg2 , arg3 , arg4 ,
s_byte_stride , t_byte_stride , arg5 , arg6 , arg7 , arg8 );
PyMem_DEL(arg2);
PyMem_DEL(arg4);
PyMem_DEL(arg5);
Py_INCREF(Py_None);
returnPy_None;
}

/* nurbscurve(knots, ctlpoints, order, type).
 The length of ctlpoints is len(knots)-order. */


staticPyObject*
gl_nurbscurve(PyObject*self, PyObject*args)
{
longarg1 ;
double*arg2 ;
longarg3 ;
double*arg4 ;
longarg5 ;
longarg6 ;
intncoords, npoints;
inti;
PyObject*v;
double*pnext;
if (!PyArg_GetLongArraySize(args, 4, 0, &arg1))
returnNULL;
if ((arg2=PyMem_NEW(double, arg1 )) ==NULL) {
returnPyErr_NoMemory();
 }
if (!PyArg_GetDoubleArray(args, 4, 0, arg1 , arg2))
returnNULL;
if (!PyArg_GetLong(args, 4, 2, &arg5))
returnNULL;
if (!PyArg_GetLong(args, 4, 3, &arg6))
returnNULL;
if (arg6==N_ST)
ncoords=2;
elseif (arg6==N_STW)
ncoords=3;
else {
PyErr_BadArgument();
returnNULL;
 }
npoints=arg1-arg5;
if (!PyArg_GetObject(args, 4, 1, &v))
returnNULL;
if (!PyList_Check(v) ||PyList_Size(v) !=npoints) {
PyErr_BadArgument();
returnNULL;
 }
if ((arg4=PyMem_NEW(double, npoints*ncoords )) ==NULL) {
returnPyErr_NoMemory();
 }
pnext=arg4;
for (i=0; i<npoints; i++) {
if (!PyArg_GetDoubleArray(PyList_GetItem(v, i), 1, 0, ncoords, pnext))
returnNULL;
pnext+=ncoords;
 }
arg3= (sizeof(double)) *ncoords;
nurbscurve( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 );
PyMem_DEL(arg2);
PyMem_DEL(arg4);
Py_INCREF(Py_None);
returnPy_None;
}

/* pwlcurve(points, type).
 Points is a list of points. Type must be N_ST. */


staticPyObject*
gl_pwlcurve(PyObject*self, PyObject*args)
{
PyObject*v;
longtype;
double*data, *pnext;
longnpoints, ncoords;
inti;
if (!PyArg_GetObject(args, 2, 0, &v))
returnNULL;
if (!PyArg_GetLong(args, 2, 1, &type))
returnNULL;
if (!PyList_Check(v)) {
PyErr_BadArgument();
returnNULL;
 }
npoints=PyList_Size(v);
if (type==N_ST)
ncoords=2;
else {
PyErr_BadArgument();
returnNULL;
 }
if ((data=PyMem_NEW(double, npoints*ncoords)) ==NULL) {
returnPyErr_NoMemory();
 }
pnext=data;
for (i=0; i<npoints; i++) {
if (!PyArg_GetDoubleArray(PyList_GetItem(v, i), 1, 0, ncoords, pnext))
returnNULL;
pnext+=ncoords;
 }
pwlcurve(npoints, data, sizeof(double)*ncoords, type);
PyMem_DEL(data);
Py_INCREF(Py_None);
returnPy_None;
}


/* Picking and Selecting */

staticshort*pickbuffer=NULL;
staticlongpickbuffersize;

staticPyObject*
pick_select(PyObject*args, void (*func)())
{
if (!PyArg_GetLong(args, 1, 0, &pickbuffersize))
returnNULL;
if (pickbuffer!=NULL) {
PyErr_SetString(PyExc_RuntimeError,
"pick/gselect: already picking/selecting");
returnNULL;
 }
if ((pickbuffer=PyMem_NEW(short, pickbuffersize)) ==NULL) {
returnPyErr_NoMemory();
 }
 (*func)(pickbuffer, pickbuffersize);
Py_INCREF(Py_None);
returnPy_None;
}

staticPyObject*
endpick_select(long (*func)())
{
PyObject*v, *w;
inti, nhits, n;
if (pickbuffer==NULL) {
PyErr_SetString(PyExc_RuntimeError,
"endpick/endselect: not in pick/select mode");
returnNULL;
 }
nhits= (*func)(pickbuffer);
if (nhits<0) {
nhits=-nhits; /* How to report buffer overflow otherwise? */
 }
/* Scan the buffer to see how many integers */
n=0;
for (; nhits>0; nhits--) {
n+=1+pickbuffer[n];
 }
v=PyList_New(n);
if (v==NULL)
returnNULL;
/* XXX Could do it nicer and interpret the data structure here,
 returning a list of lists. But this can be done in Python... */
for (i=0; i<n; i++) {
w=PyInt_FromLong((long)pickbuffer[i]);
if (w==NULL) {
Py_DECREF(v);
returnNULL;
 }
PyList_SetItem(v, i, w);
 }
PyMem_DEL(pickbuffer);
pickbuffer=NULL;
returnv;
}

externvoidpick(), gselect();
externlongendpick(), endselect();

staticPyObject*gl_pick(PyObject*self, PyObject*args)
{
returnpick_select(args, pick);
}

staticPyObject*gl_endpick(PyObject*self)
{
returnendpick_select(endpick);
}

staticPyObject*gl_gselect(PyObject*self, PyObject*args)
{
returnpick_select(args, gselect);
}

staticPyObject*gl_endselect(PyObject*self)
{
returnendpick_select(endselect);
}


/* XXX The generator botches this one. Here's a quick hack to fix it. */

/* XXX The generator botches this one. Here's a quick hack to fix it. */


staticPyObject*
gl_getmatrix(PyObject*self, PyObject*args)
{
Matrixarg1;
PyObject*v, *w;
inti, j;
getmatrix( arg1 );
v=PyList_New(16);
if (v==NULL) {
returnPyErr_NoMemory();
 }
for (i=0; i<4; i++) for (j=0; j<4; j++) {
w=mknewfloatobject(arg1[i][j]);
if (w==NULL) {
Py_DECREF(v);
returnNULL;
 }
PyList_SetItem(v, i*4+j, w);
 }
returnv;
}

/* Here's an alternate version that returns a 4x4 matrix instead of
 a vector. Unfortunately it is incompatible with loadmatrix and
 multmatrix... */


staticPyObject*
gl_altgetmatrix(PyObject*self, PyObject*args)
{
Matrixarg1;
PyObject*v, *w;
inti, j;
getmatrix( arg1 );
v=PyList_New(4);
if (v==NULL) {
returnNULL;
 }
for (i=0; i<4; i++) {
w=PyList_New(4);
if (w==NULL) {
Py_DECREF(v);
returnNULL;
 }
PyList_SetItem(v, i, w);
 }
for (i=0; i<4; i++) {
for (j=0; j<4; j++) {
w=mknewfloatobject(arg1[i][j]);
if (w==NULL) {
Py_DECREF(v);
returnNULL;
 }
PyList_SetItem(PyList_GetItem(v, i), j, w);
 }
 }
returnv;
}


staticPyObject*
gl_lrectwrite(PyObject*self, PyObject*args)
{
shortx1 ;
shorty1 ;
shortx2 ;
shorty2 ;
stringparray ;
PyObject*s;
#if0
intpixcount;
#endif
if (!PyArg_GetShort(args, 5, 0, &x1))
returnNULL;
if (!PyArg_GetShort(args, 5, 1, &y1))
returnNULL;
if (!PyArg_GetShort(args, 5, 2, &x2))
returnNULL;
if (!PyArg_GetShort(args, 5, 3, &y2))
returnNULL;
if (!PyArg_GetString(args, 5, 4, &parray))
returnNULL;
if (!PyArg_GetObject(args, 5, 4, &s))
returnNULL;
#if0
/* Don't check this, it breaks experiments with pixmode(PM_SIZE, ...) */
pixcount= (long)(x2+1-x1) * (long)(y2+1-y1);
if (!PyString_Check(s) ||PyString_Size(s) !=pixcount*sizeof(long)) {
PyErr_SetString(PyExc_RuntimeError,
"string arg to lrectwrite has wrong size");
returnNULL;
 }
#endif
lrectwrite( x1 , y1 , x2 , y2 , (unsigned long*) parray );
Py_INCREF(Py_None);
returnPy_None;
}


staticPyObject*
gl_lrectread(PyObject*self, PyObject*args)
{
shortx1 ;
shorty1 ;
shortx2 ;
shorty2 ;
PyObject*parray;
intpixcount;
if (!PyArg_GetShort(args, 4, 0, &x1))
returnNULL;
if (!PyArg_GetShort(args, 4, 1, &y1))
returnNULL;
if (!PyArg_GetShort(args, 4, 2, &x2))
returnNULL;
if (!PyArg_GetShort(args, 4, 3, &y2))
returnNULL;
pixcount= (long)(x2+1-x1) * (long)(y2+1-y1);
parray=PyString_FromStringAndSize((char*)NULL, pixcount*sizeof(long));
if (parray==NULL)
returnNULL; /* No memory */
lrectread(x1, y1, x2, y2, (unsigned long*) PyString_AsString(parray));
returnparray;
}


staticPyObject*
gl_readdisplay(PyObject*self, PyObject*args)
{
shortx1, y1, x2, y2;
unsigned long*parray, hints;
longsize, size_ret;
PyObject*rv;

if ( !PyArg_Parse(args, "hhhhl", &x1, &y1, &x2, &y2, &hints) )
return0;
size= (long)(x2+1-x1) * (long)(y2+1-y1);
rv=PyString_FromStringAndSize((char*)NULL, size*sizeof(long));
if ( rv==NULL )
returnNULL;
parray= (unsigned long*)PyString_AsString(rv);
size_ret=readdisplay(x1, y1, x2, y2, parray, hints);
if ( size_ret!=size ) {
printf("gl_readdisplay: got %ld pixels, expected %ld\n",
size_ret, size);
PyErr_SetString(PyExc_RuntimeError, "readdisplay returned unexpected length");
returnNULL;
 }
returnrv;
}

/* Desperately needed, here are tools to compress and decompress
 the data manipulated by lrectread/lrectwrite.

 gl.packrect(width, height, packfactor, bigdata) --> smalldata
 makes 'bigdata' 4*(packfactor**2) times smaller by:
 - turning it into B/W (a factor 4)
 - replacing squares of size pacfactor by one
 representative

 gl.unpackrect(width, height, packfactor, smalldata) --> bigdata
 is the inverse; the numeric arguments must be *the same*.

 Both work best if width and height are multiples of packfactor
 (in fact unpackrect will leave garbage bytes).
*/


staticPyObject*
gl_packrect(PyObject*self, PyObject*args)
{
longwidth, height, packfactor;
char*s;
PyObject*unpacked, *packed;
intpixcount, packedcount, x, y, r, g, b;
unsigned longpixel;
unsigned char*p;
unsigned long*parray;
if (!PyArg_GetLong(args, 4, 0, &width))
returnNULL;
if (!PyArg_GetLong(args, 4, 1, &height))
returnNULL;
if (!PyArg_GetLong(args, 4, 2, &packfactor))
returnNULL;
if (!PyArg_GetString(args, 4, 3, &s)) /* For type checking only */
returnNULL;
if (!PyArg_GetObject(args, 4, 3, &unpacked))
returnNULL;
if (width <= 0||height <= 0||packfactor <= 0) {
PyErr_SetString(PyExc_RuntimeError, "packrect args must be > 0");
returnNULL;
 }
pixcount=width*height;
packedcount= ((width+packfactor-1)/packfactor) *
 ((height+packfactor-1)/packfactor);
if (PyString_Size(unpacked) !=pixcount*sizeof(long)) {
PyErr_SetString(PyExc_RuntimeError,
"string arg to packrect has wrong size");
returnNULL;
 }
packed=PyString_FromStringAndSize((char*)NULL, packedcount);
if (packed==NULL)
returnNULL;
parray= (unsigned long*) PyString_AsString(unpacked);
p= (unsigned char*) PyString_AsString(packed);
for (y=0; y<height; y+=packfactor, parray+=packfactor*width) {
for (x=0; x<width; x+=packfactor) {
pixel=parray[x];
r=pixel&0xff;
g= (pixel >> 8) &0xff;
b= (pixel >> 16) &0xff;
*p++= (30*r+59*g+11*b) / 100;
 }
 }
returnpacked;
}


staticunsigned longunpacktab[256];
staticintunpacktab_inited=0;

staticPyObject*
gl_unpackrect(PyObject*self, PyObject*args)
{
longwidth, height, packfactor;
char*s;
PyObject*unpacked, *packed;
intpixcount, packedcount;
 register unsigned char*p;
 register unsigned long*parray;
if (!unpacktab_inited) {
 register intwhite;
for (white=256; --white >= 0; )
unpacktab[white] =white*0x010101L;
unpacktab_inited++;
 }
if (!PyArg_GetLong(args, 4, 0, &width))
returnNULL;
if (!PyArg_GetLong(args, 4, 1, &height))
returnNULL;
if (!PyArg_GetLong(args, 4, 2, &packfactor))
returnNULL;
if (!PyArg_GetString(args, 4, 3, &s)) /* For type checking only */
returnNULL;
if (!PyArg_GetObject(args, 4, 3, &packed))
returnNULL;
if (width <= 0||height <= 0||packfactor <= 0) {
PyErr_SetString(PyExc_RuntimeError, "packrect args must be > 0");
returnNULL;
 }
pixcount=width*height;
packedcount= ((width+packfactor-1)/packfactor) *
 ((height+packfactor-1)/packfactor);
if (PyString_Size(packed) !=packedcount) {
PyErr_SetString(PyExc_RuntimeError,
"string arg to unpackrect has wrong size");
returnNULL;
 }
unpacked=PyString_FromStringAndSize((char*)NULL, pixcount*sizeof(long));
if (unpacked==NULL)
returnNULL;
parray= (unsigned long*) PyString_AsString(unpacked);
p= (unsigned char*) PyString_AsString(packed);
if (packfactor==1&&width*height>0) {
/* Just expand bytes to longs */
 register intx=width*height;
do {
*parray++=unpacktab[*p++];
 } while (--x >= 0);
 }
else {
 register inty;
for (y=0; y<height-packfactor+1;
y+=packfactor, parray+=packfactor*width) {
 register intx;
for (x=0; x<width-packfactor+1; x+=packfactor) {
 register unsigned longpixel=unpacktab[*p++];
 register inti;
for (i=packfactor*width; (i-=width) >= 0;) {
 register intj;
for (j=packfactor; --j >= 0; )
parray[i+x+j] =pixel;
 }
 }
 }
 }
returnunpacked;
}

staticPyObject*
gl_gversion(PyObject*self, PyObject*args)
{
charbuf[20];
gversion(buf);
returnPyString_FromString(buf);
}


/* void clear - Manual because of clash with termcap */
staticPyObject*
gl_clear(PyObject*self, PyObject*args)
{
__GLclear( );
Py_INCREF(Py_None);
returnPy_None;
}

/* End of manually written stubs */


/* long getshade */

staticPyObject*
gl_getshade(PyObject*self, PyObject*args)
{
longretval;
retval=getshade( );
returnmknewlongobject(retval);
}

/* void devport short s long s */

staticPyObject*
gl_devport(PyObject*self, PyObject*args)
{
shortarg1 ;
longarg2 ;
if (!getishortarg(args, 2, 0, &arg1))
returnNULL;
if (!getilongarg(args, 2, 1, &arg2))
returnNULL;
devport( arg1 , arg2 );
Py_INCREF(Py_None);
returnPy_None;
}

/* void rdr2i long s long s */

staticPyObject*
gl_rdr2i(PyObject*self, PyObject*args)
{
longarg1 ;
longarg2 ;
if (!getilongarg(args, 2, 0, &arg1))
returnNULL;
if (!getilongarg(args, 2, 1, &arg2))
returnNULL;
rdr2i( arg1 , arg2 );
Py_INCREF(Py_None);
returnPy_None;
}

/* void rectfs short s short s short s short s */

staticPyObject*
gl_rectfs(PyObject*self, PyObject*args)
{
shortarg1 ;
shortarg2 ;
shortarg3 ;
shortarg4 ;
if (!getishortarg(args, 4, 0, &arg1))
returnNULL;
if (!getishortarg(args, 4, 1, &arg2))
returnNULL;
if (!getishortarg(args, 4, 2, &arg3))
returnNULL;
if (!getishortarg(args, 4, 3, &arg4))
returnNULL;
rectfs( arg1 , arg2 , arg3 , arg4 );
Py_INCREF(Py_None);
returnPy_None;
}

/* void rects short s short s short s short s */

staticPyObject*
gl_rects(PyObject*self, PyObject*args)
{
shortarg1 ;
shortarg2 ;
shortarg3 ;
shortarg4 ;
if (!getishortarg(args, 4, 0, &arg1))
returnNULL;
if (!getishortarg(args, 4, 1, &arg2))
returnNULL;
if (!getishortarg(args, 4, 2, &arg3))
returnNULL;
if (!getishortarg(args, 4, 3, &arg4))
returnNULL;
rects( arg1 , arg2 , arg3 , arg4 );
Py_INCREF(Py_None);
returnPy_None;
}

/* void rmv2i long s long s */

staticPyObject*
gl_rmv2i(PyObject*self, PyObject*args)
{
longarg1 ;
longarg2 ;
if (!getilongarg(args, 2, 0, &arg1))
returnNULL;
if (!getilongarg(args, 2, 1, &arg2))
returnNULL;
rmv2i( arg1 , arg2 );
Py_INCREF(Py_None);
returnPy_None;
}

/* void noport */

staticPyObject*
gl_noport(PyObject*self, PyObject*args)
{
noport( );
Py_INCREF(Py_None);
returnPy_None;
}

/* void popviewport */

staticPyObject*
gl_popviewport(PyObject*self, PyObject*args)
{
popviewport( );
Py_INCREF(Py_None);
returnPy_None;
}

/* void clearhitcode */

staticPyObject*
gl_clearhitcode(PyObject*self, PyObject*args)
{
clearhitcode( );
Py_INCREF(Py_None);
returnPy_None;
}

/* void closeobj */

staticPyObject*
gl_closeobj(PyObject*self, PyObject*args)
{
closeobj( );
Py_INCREF(Py_None);
returnPy_None;
}

/* void cursoff */

staticPyObject*
gl_cursoff(PyObject*self, PyObject*args)
{
cursoff( );
Py_INCREF(Py_None);
returnPy_None;
}

/* void curson */

staticPyObject*
gl_curson(PyObject*self, PyObject*args)
{
curson( );
Py_INCREF(Py_None);
returnPy_None;
}

/* void doublebuffer */

staticPyObject*
gl_doublebuffer(PyObject*self, PyObject*args)
{
doublebuffer( );
Py_INCREF(Py_None);
returnPy_None;
}

/* void finish */

staticPyObject*
gl_finish(PyObject*self, PyObject*args)
{
finish( );
Py_INCREF(Py_None);
returnPy_None;
}

/* void gconfig */