diff -r ffa851df0825 -r 2fb8b9db1c86 symbian-qemu-0.9.1-12/python-2.6.1/Modules/glmodule.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/symbian-qemu-0.9.1-12/python-2.6.1/Modules/glmodule.c Fri Jul 31 15:01:17 2009 +0100 @@ -0,0 +1,7633 @@ + +/* +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: + + + + can be: void, short, long (XXX maybe others?) + + can be: char, string, short, float, long, or double + string indicates a null terminated string; + if is char and begins with a *, the * is stripped + and is changed into string + + has the form or [] + where can be + s: arg is sent + r: arg is received (arg is a pointer) + and 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 +#include + +#ifdef __sgi +extern int devport(); +extern int textwritemask(); +extern int pagewritemask(); +extern int gewrite(); +extern int gettp(); +#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. +*/ + + +static PyObject * +gl_qread(PyObject *self, PyObject *args) +{ + long retval; + short arg1 ; + Py_BEGIN_ALLOW_THREADS + retval = qread( & arg1 ); + Py_END_ALLOW_THREADS + { PyObject *v = PyTuple_New( 2 ); + if (v == NULL) return NULL; + PyTuple_SetItem(v, 0, mknewlongobject(retval)); + PyTuple_SetItem(v, 1, mknewshortobject(arg1)); + return v; + } +} + + +/* +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. +*/ + + +static PyObject * +gl_varray(PyObject *self, PyObject *args) +{ + PyObject *v, *w=NULL; + int i, n, width; + double vec[3]; + PyObject * (*getitem)(PyObject *, int); + + if (!PyArg_GetObject(args, 1, 0, &v)) + return NULL; + + if (PyList_Check(v)) { + n = PyList_Size(v); + getitem = PyList_GetItem; + } + else if (PyTuple_Check(v)) { + n = PyTuple_Size(v); + getitem = PyTuple_GetItem; + } + else { + PyErr_BadArgument(); + return NULL; + } + + if (n == 0) { + Py_INCREF(Py_None); + return Py_None; + } + if (n > 0) + w = (*getitem)(v, 0); + + width = 0; + if (w == NULL) { + } + else if (PyList_Check(w)) { + width = PyList_Size(w); + } + else if (PyTuple_Check(w)) { + width = PyTuple_Size(w); + } + + switch (width) { + case 2: + vec[2] = 0.0; + /* Fall through */ + case 3: + break; + default: + PyErr_BadArgument(); + return NULL; + } + + for (i = 0; i < n; i++) { + w = (*getitem)(v, i); + if (!PyArg_GetDoubleArray(w, 1, 0, width, vec)) + return NULL; + v3d(vec); + } + + Py_INCREF(Py_None); + return Py_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). +*/ + +static PyObject *gen_nvarray(); /* Forward */ + + +static PyObject * +gl_nvarray(PyObject *self, PyObject *args) +{ + return gen_nvarray(args, 0); +} + + +static PyObject * +gl_vnarray(PyObject *self, PyObject *args) +{ + return gen_nvarray(args, 1); +} + +/* Generic, internal version of {nv,nv}array: inorm indicates the + argument order, 0: normal first, 1: vector first. */ + +static PyObject * +gen_nvarray(PyObject *args, int inorm) +{ + PyObject *v, *w, *wnorm, *wvec; + int i, n; + float norm[3], vec[3]; + PyObject * (*getitem)(PyObject *, int); + + if (!PyArg_GetObject(args, 1, 0, &v)) + return NULL; + + if (PyList_Check(v)) { + n = PyList_Size(v); + getitem = PyList_GetItem; + } + else if (PyTuple_Check(v)) { + n = PyTuple_Size(v); + getitem = PyTuple_GetItem; + } + else { + PyErr_BadArgument(); + return NULL; + } + + for (i = 0; i < n; i++) { + w = (*getitem)(v, i); + if (!PyTuple_Check(w) || PyTuple_Size(w) != 2) { + PyErr_BadArgument(); + return NULL; + } + 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)) + return NULL; + n3f(norm); + v3f(vec); + } + + Py_INCREF(Py_None); + return Py_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] +*/ + + +static PyObject * +gl_nurbssurface(PyObject *self, PyObject *args) +{ + long arg1 ; + double * arg2 ; + long arg3 ; + double * arg4 ; + double *arg5 ; + long arg6 ; + long arg7 ; + long arg8 ; + long ncoords; + long s_byte_stride, t_byte_stride; + long s_nctl, t_nctl; + long s, t; + PyObject *v, *w, *pt; + double *pnext; + if (!PyArg_GetLongArraySize(args, 6, 0, &arg1)) + return NULL; + if ((arg2 = PyMem_NEW(double, arg1 )) == NULL) { + return PyErr_NoMemory(); + } + if (!PyArg_GetDoubleArray(args, 6, 0, arg1 , arg2)) + return NULL; + if (!PyArg_GetLongArraySize(args, 6, 1, &arg3)) + return NULL; + if ((arg4 = PyMem_NEW(double, arg3 )) == NULL) { + return PyErr_NoMemory(); + } + if (!PyArg_GetDoubleArray(args, 6, 1, arg3 , arg4)) + return NULL; + if (!PyArg_GetLong(args, 6, 3, &arg6)) + return NULL; + if (!PyArg_GetLong(args, 6, 4, &arg7)) + return NULL; + if (!PyArg_GetLong(args, 6, 5, &arg8)) + return NULL; + if (arg8 == N_XYZ) + ncoords = 3; + else if (arg8 == N_XYZW) + ncoords = 4; + else { + PyErr_BadArgument(); + return NULL; + } + s_nctl = arg1 - arg6; + t_nctl = arg3 - arg7; + if (!PyArg_GetObject(args, 6, 2, &v)) + return NULL; + if (!PyList_Check(v) || PyList_Size(v) != s_nctl) { + PyErr_BadArgument(); + return NULL; + } + if ((arg5 = PyMem_NEW(double, s_nctl*t_nctl*ncoords )) == NULL) { + return PyErr_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(); + return NULL; + } + for (t = 0; t < t_nctl; t++) { + pt = PyList_GetItem(w, t); + if (!PyArg_GetDoubleArray(pt, 1, 0, ncoords, pnext)) + return NULL; + 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); + return Py_None; +} + +/* nurbscurve(knots, ctlpoints, order, type). + The length of ctlpoints is len(knots)-order. */ + + +static PyObject * +gl_nurbscurve(PyObject *self, PyObject *args) +{ + long arg1 ; + double * arg2 ; + long arg3 ; + double * arg4 ; + long arg5 ; + long arg6 ; + int ncoords, npoints; + int i; + PyObject *v; + double *pnext; + if (!PyArg_GetLongArraySize(args, 4, 0, &arg1)) + return NULL; + if ((arg2 = PyMem_NEW(double, arg1 )) == NULL) { + return PyErr_NoMemory(); + } + if (!PyArg_GetDoubleArray(args, 4, 0, arg1 , arg2)) + return NULL; + if (!PyArg_GetLong(args, 4, 2, &arg5)) + return NULL; + if (!PyArg_GetLong(args, 4, 3, &arg6)) + return NULL; + if (arg6 == N_ST) + ncoords = 2; + else if (arg6 == N_STW) + ncoords = 3; + else { + PyErr_BadArgument(); + return NULL; + } + npoints = arg1 - arg5; + if (!PyArg_GetObject(args, 4, 1, &v)) + return NULL; + if (!PyList_Check(v) || PyList_Size(v) != npoints) { + PyErr_BadArgument(); + return NULL; + } + if ((arg4 = PyMem_NEW(double, npoints*ncoords )) == NULL) { + return PyErr_NoMemory(); + } + pnext = arg4; + for (i = 0; i < npoints; i++) { + if (!PyArg_GetDoubleArray(PyList_GetItem(v, i), 1, 0, ncoords, pnext)) + return NULL; + pnext += ncoords; + } + arg3 = (sizeof(double)) * ncoords; + nurbscurve( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 ); + PyMem_DEL(arg2); + PyMem_DEL(arg4); + Py_INCREF(Py_None); + return Py_None; +} + +/* pwlcurve(points, type). + Points is a list of points. Type must be N_ST. */ + + +static PyObject * +gl_pwlcurve(PyObject *self, PyObject *args) +{ + PyObject *v; + long type; + double *data, *pnext; + long npoints, ncoords; + int i; + if (!PyArg_GetObject(args, 2, 0, &v)) + return NULL; + if (!PyArg_GetLong(args, 2, 1, &type)) + return NULL; + if (!PyList_Check(v)) { + PyErr_BadArgument(); + return NULL; + } + npoints = PyList_Size(v); + if (type == N_ST) + ncoords = 2; + else { + PyErr_BadArgument(); + return NULL; + } + if ((data = PyMem_NEW(double, npoints*ncoords)) == NULL) { + return PyErr_NoMemory(); + } + pnext = data; + for (i = 0; i < npoints; i++) { + if (!PyArg_GetDoubleArray(PyList_GetItem(v, i), 1, 0, ncoords, pnext)) + return NULL; + pnext += ncoords; + } + pwlcurve(npoints, data, sizeof(double)*ncoords, type); + PyMem_DEL(data); + Py_INCREF(Py_None); + return Py_None; +} + + +/* Picking and Selecting */ + +static short *pickbuffer = NULL; +static long pickbuffersize; + +static PyObject * +pick_select(PyObject *args, void (*func)()) +{ + if (!PyArg_GetLong(args, 1, 0, &pickbuffersize)) + return NULL; + if (pickbuffer != NULL) { + PyErr_SetString(PyExc_RuntimeError, + "pick/gselect: already picking/selecting"); + return NULL; + } + if ((pickbuffer = PyMem_NEW(short, pickbuffersize)) == NULL) { + return PyErr_NoMemory(); + } + (*func)(pickbuffer, pickbuffersize); + Py_INCREF(Py_None); + return Py_None; +} + +static PyObject * +endpick_select(long (*func)()) +{ + PyObject *v, *w; + int i, nhits, n; + if (pickbuffer == NULL) { + PyErr_SetString(PyExc_RuntimeError, + "endpick/endselect: not in pick/select mode"); + return NULL; + } + 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) + return NULL; + /* 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); + return NULL; + } + PyList_SetItem(v, i, w); + } + PyMem_DEL(pickbuffer); + pickbuffer = NULL; + return v; +} + +extern void pick(), gselect(); +extern long endpick(), endselect(); + +static PyObject *gl_pick(PyObject *self, PyObject *args) +{ + return pick_select(args, pick); +} + +static PyObject *gl_endpick(PyObject *self) +{ + return endpick_select(endpick); +} + +static PyObject *gl_gselect(PyObject *self, PyObject *args) +{ + return pick_select(args, gselect); +} + +static PyObject *gl_endselect(PyObject *self) +{ + return endpick_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. */ + + +static PyObject * +gl_getmatrix(PyObject *self, PyObject *args) +{ + Matrix arg1; + PyObject *v, *w; + int i, j; + getmatrix( arg1 ); + v = PyList_New(16); + if (v == NULL) { + return PyErr_NoMemory(); + } + for (i = 0; i < 4; i++) for (j = 0; j < 4; j++) { + w = mknewfloatobject(arg1[i][j]); + if (w == NULL) { + Py_DECREF(v); + return NULL; + } + PyList_SetItem(v, i*4+j, w); + } + return v; +} + +/* Here's an alternate version that returns a 4x4 matrix instead of + a vector. Unfortunately it is incompatible with loadmatrix and + multmatrix... */ + + +static PyObject * +gl_altgetmatrix(PyObject *self, PyObject *args) +{ + Matrix arg1; + PyObject *v, *w; + int i, j; + getmatrix( arg1 ); + v = PyList_New(4); + if (v == NULL) { + return NULL; + } + for (i = 0; i < 4; i++) { + w = PyList_New(4); + if (w == NULL) { + Py_DECREF(v); + return NULL; + } + 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); + return NULL; + } + PyList_SetItem(PyList_GetItem(v, i), j, w); + } + } + return v; +} + + +static PyObject * +gl_lrectwrite(PyObject *self, PyObject *args) +{ + short x1 ; + short y1 ; + short x2 ; + short y2 ; + string parray ; + PyObject *s; +#if 0 + int pixcount; +#endif + if (!PyArg_GetShort(args, 5, 0, &x1)) + return NULL; + if (!PyArg_GetShort(args, 5, 1, &y1)) + return NULL; + if (!PyArg_GetShort(args, 5, 2, &x2)) + return NULL; + if (!PyArg_GetShort(args, 5, 3, &y2)) + return NULL; + if (!PyArg_GetString(args, 5, 4, &parray)) + return NULL; + if (!PyArg_GetObject(args, 5, 4, &s)) + return NULL; +#if 0 +/* 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"); + return NULL; + } +#endif + lrectwrite( x1 , y1 , x2 , y2 , (unsigned long *) parray ); + Py_INCREF(Py_None); + return Py_None; +} + + +static PyObject * +gl_lrectread(PyObject *self, PyObject *args) +{ + short x1 ; + short y1 ; + short x2 ; + short y2 ; + PyObject *parray; + int pixcount; + if (!PyArg_GetShort(args, 4, 0, &x1)) + return NULL; + if (!PyArg_GetShort(args, 4, 1, &y1)) + return NULL; + if (!PyArg_GetShort(args, 4, 2, &x2)) + return NULL; + if (!PyArg_GetShort(args, 4, 3, &y2)) + return NULL; + pixcount = (long)(x2+1-x1) * (long)(y2+1-y1); + parray = PyString_FromStringAndSize((char *)NULL, pixcount*sizeof(long)); + if (parray == NULL) + return NULL; /* No memory */ + lrectread(x1, y1, x2, y2, (unsigned long *) PyString_AsString(parray)); + return parray; +} + + +static PyObject * +gl_readdisplay(PyObject *self, PyObject *args) +{ + short x1, y1, x2, y2; + unsigned long *parray, hints; + long size, size_ret; + PyObject *rv; + + if ( !PyArg_Parse(args, "hhhhl", &x1, &y1, &x2, &y2, &hints) ) + return 0; + size = (long)(x2+1-x1) * (long)(y2+1-y1); + rv = PyString_FromStringAndSize((char *)NULL, size*sizeof(long)); + if ( rv == NULL ) + return NULL; + 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"); + return NULL; + } + return rv; +} + +/* 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). +*/ + + +static PyObject * +gl_packrect(PyObject *self, PyObject *args) +{ + long width, height, packfactor; + char *s; + PyObject *unpacked, *packed; + int pixcount, packedcount, x, y, r, g, b; + unsigned long pixel; + unsigned char *p; + unsigned long *parray; + if (!PyArg_GetLong(args, 4, 0, &width)) + return NULL; + if (!PyArg_GetLong(args, 4, 1, &height)) + return NULL; + if (!PyArg_GetLong(args, 4, 2, &packfactor)) + return NULL; + if (!PyArg_GetString(args, 4, 3, &s)) /* For type checking only */ + return NULL; + if (!PyArg_GetObject(args, 4, 3, &unpacked)) + return NULL; + if (width <= 0 || height <= 0 || packfactor <= 0) { + PyErr_SetString(PyExc_RuntimeError, "packrect args must be > 0"); + return NULL; + } + 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"); + return NULL; + } + packed = PyString_FromStringAndSize((char *)NULL, packedcount); + if (packed == NULL) + return NULL; + 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; + } + } + return packed; +} + + +static unsigned long unpacktab[256]; +static int unpacktab_inited = 0; + +static PyObject * +gl_unpackrect(PyObject *self, PyObject *args) +{ + long width, height, packfactor; + char *s; + PyObject *unpacked, *packed; + int pixcount, packedcount; + register unsigned char *p; + register unsigned long *parray; + if (!unpacktab_inited) { + register int white; + for (white = 256; --white >= 0; ) + unpacktab[white] = white * 0x010101L; + unpacktab_inited++; + } + if (!PyArg_GetLong(args, 4, 0, &width)) + return NULL; + if (!PyArg_GetLong(args, 4, 1, &height)) + return NULL; + if (!PyArg_GetLong(args, 4, 2, &packfactor)) + return NULL; + if (!PyArg_GetString(args, 4, 3, &s)) /* For type checking only */ + return NULL; + if (!PyArg_GetObject(args, 4, 3, &packed)) + return NULL; + if (width <= 0 || height <= 0 || packfactor <= 0) { + PyErr_SetString(PyExc_RuntimeError, "packrect args must be > 0"); + return NULL; + } + 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"); + return NULL; + } + unpacked = PyString_FromStringAndSize((char *)NULL, pixcount*sizeof(long)); + if (unpacked == NULL) + return NULL; + parray = (unsigned long *) PyString_AsString(unpacked); + p = (unsigned char *) PyString_AsString(packed); + if (packfactor == 1 && width*height > 0) { + /* Just expand bytes to longs */ + register int x = width * height; + do { + *parray++ = unpacktab[*p++]; + } while (--x >= 0); + } + else { + register int y; + for (y = 0; y < height-packfactor+1; + y += packfactor, parray += packfactor*width) { + register int x; + for (x = 0; x < width-packfactor+1; x += packfactor) { + register unsigned long pixel = unpacktab[*p++]; + register int i; + for (i = packfactor*width; (i-=width) >= 0;) { + register int j; + for (j = packfactor; --j >= 0; ) + parray[i+x+j] = pixel; + } + } + } + } + return unpacked; +} + +static PyObject * +gl_gversion(PyObject *self, PyObject *args) +{ + char buf[20]; + gversion(buf); + return PyString_FromString(buf); +} + + +/* void clear - Manual because of clash with termcap */ +static PyObject * +gl_clear(PyObject *self, PyObject *args) +{ + __GLclear( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* End of manually written stubs */ + + +/* long getshade */ + +static PyObject * +gl_getshade(PyObject *self, PyObject *args) +{ + long retval; + retval = getshade( ); + return mknewlongobject(retval); +} + +/* void devport short s long s */ + +static PyObject * +gl_devport(PyObject *self, PyObject *args) +{ + short arg1 ; + long arg2 ; + if (!getishortarg(args, 2, 0, &arg1)) + return NULL; + if (!getilongarg(args, 2, 1, &arg2)) + return NULL; + devport( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void rdr2i long s long s */ + +static PyObject * +gl_rdr2i(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + if (!getilongarg(args, 2, 0, &arg1)) + return NULL; + if (!getilongarg(args, 2, 1, &arg2)) + return NULL; + rdr2i( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void rectfs short s short s short s short s */ + +static PyObject * +gl_rectfs(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + short arg4 ; + if (!getishortarg(args, 4, 0, &arg1)) + return NULL; + if (!getishortarg(args, 4, 1, &arg2)) + return NULL; + if (!getishortarg(args, 4, 2, &arg3)) + return NULL; + if (!getishortarg(args, 4, 3, &arg4)) + return NULL; + rectfs( arg1 , arg2 , arg3 , arg4 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void rects short s short s short s short s */ + +static PyObject * +gl_rects(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + short arg4 ; + if (!getishortarg(args, 4, 0, &arg1)) + return NULL; + if (!getishortarg(args, 4, 1, &arg2)) + return NULL; + if (!getishortarg(args, 4, 2, &arg3)) + return NULL; + if (!getishortarg(args, 4, 3, &arg4)) + return NULL; + rects( arg1 , arg2 , arg3 , arg4 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void rmv2i long s long s */ + +static PyObject * +gl_rmv2i(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + if (!getilongarg(args, 2, 0, &arg1)) + return NULL; + if (!getilongarg(args, 2, 1, &arg2)) + return NULL; + rmv2i( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void noport */ + +static PyObject * +gl_noport(PyObject *self, PyObject *args) +{ + noport( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void popviewport */ + +static PyObject * +gl_popviewport(PyObject *self, PyObject *args) +{ + popviewport( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void clearhitcode */ + +static PyObject * +gl_clearhitcode(PyObject *self, PyObject *args) +{ + clearhitcode( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void closeobj */ + +static PyObject * +gl_closeobj(PyObject *self, PyObject *args) +{ + closeobj( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void cursoff */ + +static PyObject * +gl_cursoff(PyObject *self, PyObject *args) +{ + cursoff( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void curson */ + +static PyObject * +gl_curson(PyObject *self, PyObject *args) +{ + curson( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void doublebuffer */ + +static PyObject * +gl_doublebuffer(PyObject *self, PyObject *args) +{ + doublebuffer( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void finish */ + +static PyObject * +gl_finish(PyObject *self, PyObject *args) +{ + finish( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void gconfig */ + +static PyObject * +gl_gconfig(PyObject *self, PyObject *args) +{ + gconfig( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void ginit */ + +static PyObject * +gl_ginit(PyObject *self, PyObject *args) +{ + ginit( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void greset */ + +static PyObject * +gl_greset(PyObject *self, PyObject *args) +{ + greset( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void multimap */ + +static PyObject * +gl_multimap(PyObject *self, PyObject *args) +{ + multimap( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void onemap */ + +static PyObject * +gl_onemap(PyObject *self, PyObject *args) +{ + onemap( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void popattributes */ + +static PyObject * +gl_popattributes(PyObject *self, PyObject *args) +{ + popattributes( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void popmatrix */ + +static PyObject * +gl_popmatrix(PyObject *self, PyObject *args) +{ + popmatrix( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void pushattributes */ + +static PyObject * +gl_pushattributes(PyObject *self, PyObject *args) +{ + pushattributes( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void pushmatrix */ + +static PyObject * +gl_pushmatrix(PyObject *self, PyObject *args) +{ + pushmatrix( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void pushviewport */ + +static PyObject * +gl_pushviewport(PyObject *self, PyObject *args) +{ + pushviewport( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void qreset */ + +static PyObject * +gl_qreset(PyObject *self, PyObject *args) +{ + qreset( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void RGBmode */ + +static PyObject * +gl_RGBmode(PyObject *self, PyObject *args) +{ + RGBmode( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void singlebuffer */ + +static PyObject * +gl_singlebuffer(PyObject *self, PyObject *args) +{ + singlebuffer( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void swapbuffers */ + +static PyObject * +gl_swapbuffers(PyObject *self, PyObject *args) +{ + swapbuffers( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void gsync */ + +static PyObject * +gl_gsync(PyObject *self, PyObject *args) +{ + gsync( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void gflush */ + +static PyObject * +gl_gflush(PyObject *self, PyObject *args) +{ + gflush( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void tpon */ + +static PyObject * +gl_tpon(PyObject *self, PyObject *args) +{ + tpon( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void tpoff */ + +static PyObject * +gl_tpoff(PyObject *self, PyObject *args) +{ + tpoff( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void clkon */ + +static PyObject * +gl_clkon(PyObject *self, PyObject *args) +{ + clkon( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void clkoff */ + +static PyObject * +gl_clkoff(PyObject *self, PyObject *args) +{ + clkoff( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void ringbell */ + +static PyObject * +gl_ringbell(PyObject *self, PyObject *args) +{ + ringbell( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void gbegin */ + +static PyObject * +gl_gbegin(PyObject *self, PyObject *args) +{ + gbegin( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void textinit */ + +static PyObject * +gl_textinit(PyObject *self, PyObject *args) +{ + textinit( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void initnames */ + +static PyObject * +gl_initnames(PyObject *self, PyObject *args) +{ + initnames( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void pclos */ + +static PyObject * +gl_pclos(PyObject *self, PyObject *args) +{ + pclos( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void popname */ + +static PyObject * +gl_popname(PyObject *self, PyObject *args) +{ + popname( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void spclos */ + +static PyObject * +gl_spclos(PyObject *self, PyObject *args) +{ + spclos( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void zclear */ + +static PyObject * +gl_zclear(PyObject *self, PyObject *args) +{ + zclear( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void screenspace */ + +static PyObject * +gl_screenspace(PyObject *self, PyObject *args) +{ + screenspace( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void reshapeviewport */ + +static PyObject * +gl_reshapeviewport(PyObject *self, PyObject *args) +{ + reshapeviewport( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void winpush */ + +static PyObject * +gl_winpush(PyObject *self, PyObject *args) +{ + winpush( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void winpop */ + +static PyObject * +gl_winpop(PyObject *self, PyObject *args) +{ + winpop( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void foreground */ + +static PyObject * +gl_foreground(PyObject *self, PyObject *args) +{ + foreground( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void endfullscrn */ + +static PyObject * +gl_endfullscrn(PyObject *self, PyObject *args) +{ + endfullscrn( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void endpupmode */ + +static PyObject * +gl_endpupmode(PyObject *self, PyObject *args) +{ + endpupmode( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void fullscrn */ + +static PyObject * +gl_fullscrn(PyObject *self, PyObject *args) +{ + fullscrn( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void pupmode */ + +static PyObject * +gl_pupmode(PyObject *self, PyObject *args) +{ + pupmode( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void winconstraints */ + +static PyObject * +gl_winconstraints(PyObject *self, PyObject *args) +{ + winconstraints( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void pagecolor short s */ + +static PyObject * +gl_pagecolor(PyObject *self, PyObject *args) +{ + short arg1 ; + if (!getishortarg(args, 1, 0, &arg1)) + return NULL; + pagecolor( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void textcolor short s */ + +static PyObject * +gl_textcolor(PyObject *self, PyObject *args) +{ + short arg1 ; + if (!getishortarg(args, 1, 0, &arg1)) + return NULL; + textcolor( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void color short s */ + +static PyObject * +gl_color(PyObject *self, PyObject *args) +{ + short arg1 ; + if (!getishortarg(args, 1, 0, &arg1)) + return NULL; + color( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void curveit short s */ + +static PyObject * +gl_curveit(PyObject *self, PyObject *args) +{ + short arg1 ; + if (!getishortarg(args, 1, 0, &arg1)) + return NULL; + curveit( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void font short s */ + +static PyObject * +gl_font(PyObject *self, PyObject *args) +{ + short arg1 ; + if (!getishortarg(args, 1, 0, &arg1)) + return NULL; + font( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void linewidth short s */ + +static PyObject * +gl_linewidth(PyObject *self, PyObject *args) +{ + short arg1 ; + if (!getishortarg(args, 1, 0, &arg1)) + return NULL; + linewidth( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void setlinestyle short s */ + +static PyObject * +gl_setlinestyle(PyObject *self, PyObject *args) +{ + short arg1 ; + if (!getishortarg(args, 1, 0, &arg1)) + return NULL; + setlinestyle( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void setmap short s */ + +static PyObject * +gl_setmap(PyObject *self, PyObject *args) +{ + short arg1 ; + if (!getishortarg(args, 1, 0, &arg1)) + return NULL; + setmap( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void swapinterval short s */ + +static PyObject * +gl_swapinterval(PyObject *self, PyObject *args) +{ + short arg1 ; + if (!getishortarg(args, 1, 0, &arg1)) + return NULL; + swapinterval( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void writemask short s */ + +static PyObject * +gl_writemask(PyObject *self, PyObject *args) +{ + short arg1 ; + if (!getishortarg(args, 1, 0, &arg1)) + return NULL; + writemask( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void textwritemask short s */ + +static PyObject * +gl_textwritemask(PyObject *self, PyObject *args) +{ + short arg1 ; + if (!getishortarg(args, 1, 0, &arg1)) + return NULL; + textwritemask( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void qdevice short s */ + +static PyObject * +gl_qdevice(PyObject *self, PyObject *args) +{ + short arg1 ; + if (!getishortarg(args, 1, 0, &arg1)) + return NULL; + qdevice( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void unqdevice short s */ + +static PyObject * +gl_unqdevice(PyObject *self, PyObject *args) +{ + short arg1 ; + if (!getishortarg(args, 1, 0, &arg1)) + return NULL; + unqdevice( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void curvebasis short s */ + +static PyObject * +gl_curvebasis(PyObject *self, PyObject *args) +{ + short arg1 ; + if (!getishortarg(args, 1, 0, &arg1)) + return NULL; + curvebasis( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void curveprecision short s */ + +static PyObject * +gl_curveprecision(PyObject *self, PyObject *args) +{ + short arg1 ; + if (!getishortarg(args, 1, 0, &arg1)) + return NULL; + curveprecision( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void loadname short s */ + +static PyObject * +gl_loadname(PyObject *self, PyObject *args) +{ + short arg1 ; + if (!getishortarg(args, 1, 0, &arg1)) + return NULL; + loadname( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void passthrough short s */ + +static PyObject * +gl_passthrough(PyObject *self, PyObject *args) +{ + short arg1 ; + if (!getishortarg(args, 1, 0, &arg1)) + return NULL; + passthrough( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void pushname short s */ + +static PyObject * +gl_pushname(PyObject *self, PyObject *args) +{ + short arg1 ; + if (!getishortarg(args, 1, 0, &arg1)) + return NULL; + pushname( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void setmonitor short s */ + +static PyObject * +gl_setmonitor(PyObject *self, PyObject *args) +{ + short arg1 ; + if (!getishortarg(args, 1, 0, &arg1)) + return NULL; + setmonitor( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void setshade short s */ + +static PyObject * +gl_setshade(PyObject *self, PyObject *args) +{ + short arg1 ; + if (!getishortarg(args, 1, 0, &arg1)) + return NULL; + setshade( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void setpattern short s */ + +static PyObject * +gl_setpattern(PyObject *self, PyObject *args) +{ + short arg1 ; + if (!getishortarg(args, 1, 0, &arg1)) + return NULL; + setpattern( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void pagewritemask short s */ + +static PyObject * +gl_pagewritemask(PyObject *self, PyObject *args) +{ + short arg1 ; + if (!getishortarg(args, 1, 0, &arg1)) + return NULL; + pagewritemask( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void callobj long s */ + +static PyObject * +gl_callobj(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + callobj( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void delobj long s */ + +static PyObject * +gl_delobj(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + delobj( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void editobj long s */ + +static PyObject * +gl_editobj(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + editobj( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void makeobj long s */ + +static PyObject * +gl_makeobj(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + makeobj( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void maketag long s */ + +static PyObject * +gl_maketag(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + maketag( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void chunksize long s */ + +static PyObject * +gl_chunksize(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + chunksize( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void compactify long s */ + +static PyObject * +gl_compactify(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + compactify( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void deltag long s */ + +static PyObject * +gl_deltag(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + deltag( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void lsrepeat long s */ + +static PyObject * +gl_lsrepeat(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + lsrepeat( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void objinsert long s */ + +static PyObject * +gl_objinsert(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + objinsert( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void objreplace long s */ + +static PyObject * +gl_objreplace(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + objreplace( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void winclose long s */ + +static PyObject * +gl_winclose(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + winclose( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void blanktime long s */ + +static PyObject * +gl_blanktime(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + blanktime( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void freepup long s */ + +static PyObject * +gl_freepup(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + freepup( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void backbuffer long s */ + +static PyObject * +gl_backbuffer(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + backbuffer( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void frontbuffer long s */ + +static PyObject * +gl_frontbuffer(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + frontbuffer( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void lsbackup long s */ + +static PyObject * +gl_lsbackup(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + lsbackup( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void resetls long s */ + +static PyObject * +gl_resetls(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + resetls( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void lampon long s */ + +static PyObject * +gl_lampon(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + lampon( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void lampoff long s */ + +static PyObject * +gl_lampoff(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + lampoff( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void setbell long s */ + +static PyObject * +gl_setbell(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + setbell( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void blankscreen long s */ + +static PyObject * +gl_blankscreen(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + blankscreen( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void depthcue long s */ + +static PyObject * +gl_depthcue(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + depthcue( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void zbuffer long s */ + +static PyObject * +gl_zbuffer(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + zbuffer( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void backface long s */ + +static PyObject * +gl_backface(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + backface( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void cmov2i long s long s */ + +static PyObject * +gl_cmov2i(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + if (!getilongarg(args, 2, 0, &arg1)) + return NULL; + if (!getilongarg(args, 2, 1, &arg2)) + return NULL; + cmov2i( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void draw2i long s long s */ + +static PyObject * +gl_draw2i(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + if (!getilongarg(args, 2, 0, &arg1)) + return NULL; + if (!getilongarg(args, 2, 1, &arg2)) + return NULL; + draw2i( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void move2i long s long s */ + +static PyObject * +gl_move2i(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + if (!getilongarg(args, 2, 0, &arg1)) + return NULL; + if (!getilongarg(args, 2, 1, &arg2)) + return NULL; + move2i( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void pnt2i long s long s */ + +static PyObject * +gl_pnt2i(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + if (!getilongarg(args, 2, 0, &arg1)) + return NULL; + if (!getilongarg(args, 2, 1, &arg2)) + return NULL; + pnt2i( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void patchbasis long s long s */ + +static PyObject * +gl_patchbasis(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + if (!getilongarg(args, 2, 0, &arg1)) + return NULL; + if (!getilongarg(args, 2, 1, &arg2)) + return NULL; + patchbasis( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void patchprecision long s long s */ + +static PyObject * +gl_patchprecision(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + if (!getilongarg(args, 2, 0, &arg1)) + return NULL; + if (!getilongarg(args, 2, 1, &arg2)) + return NULL; + patchprecision( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void pdr2i long s long s */ + +static PyObject * +gl_pdr2i(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + if (!getilongarg(args, 2, 0, &arg1)) + return NULL; + if (!getilongarg(args, 2, 1, &arg2)) + return NULL; + pdr2i( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void pmv2i long s long s */ + +static PyObject * +gl_pmv2i(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + if (!getilongarg(args, 2, 0, &arg1)) + return NULL; + if (!getilongarg(args, 2, 1, &arg2)) + return NULL; + pmv2i( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void rpdr2i long s long s */ + +static PyObject * +gl_rpdr2i(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + if (!getilongarg(args, 2, 0, &arg1)) + return NULL; + if (!getilongarg(args, 2, 1, &arg2)) + return NULL; + rpdr2i( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void rpmv2i long s long s */ + +static PyObject * +gl_rpmv2i(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + if (!getilongarg(args, 2, 0, &arg1)) + return NULL; + if (!getilongarg(args, 2, 1, &arg2)) + return NULL; + rpmv2i( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void xfpt2i long s long s */ + +static PyObject * +gl_xfpt2i(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + if (!getilongarg(args, 2, 0, &arg1)) + return NULL; + if (!getilongarg(args, 2, 1, &arg2)) + return NULL; + xfpt2i( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void objdelete long s long s */ + +static PyObject * +gl_objdelete(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + if (!getilongarg(args, 2, 0, &arg1)) + return NULL; + if (!getilongarg(args, 2, 1, &arg2)) + return NULL; + objdelete( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void patchcurves long s long s */ + +static PyObject * +gl_patchcurves(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + if (!getilongarg(args, 2, 0, &arg1)) + return NULL; + if (!getilongarg(args, 2, 1, &arg2)) + return NULL; + patchcurves( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void minsize long s long s */ + +static PyObject * +gl_minsize(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + if (!getilongarg(args, 2, 0, &arg1)) + return NULL; + if (!getilongarg(args, 2, 1, &arg2)) + return NULL; + minsize( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void maxsize long s long s */ + +static PyObject * +gl_maxsize(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + if (!getilongarg(args, 2, 0, &arg1)) + return NULL; + if (!getilongarg(args, 2, 1, &arg2)) + return NULL; + maxsize( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void keepaspect long s long s */ + +static PyObject * +gl_keepaspect(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + if (!getilongarg(args, 2, 0, &arg1)) + return NULL; + if (!getilongarg(args, 2, 1, &arg2)) + return NULL; + keepaspect( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void prefsize long s long s */ + +static PyObject * +gl_prefsize(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + if (!getilongarg(args, 2, 0, &arg1)) + return NULL; + if (!getilongarg(args, 2, 1, &arg2)) + return NULL; + prefsize( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void stepunit long s long s */ + +static PyObject * +gl_stepunit(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + if (!getilongarg(args, 2, 0, &arg1)) + return NULL; + if (!getilongarg(args, 2, 1, &arg2)) + return NULL; + stepunit( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void fudge long s long s */ + +static PyObject * +gl_fudge(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + if (!getilongarg(args, 2, 0, &arg1)) + return NULL; + if (!getilongarg(args, 2, 1, &arg2)) + return NULL; + fudge( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void winmove long s long s */ + +static PyObject * +gl_winmove(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + if (!getilongarg(args, 2, 0, &arg1)) + return NULL; + if (!getilongarg(args, 2, 1, &arg2)) + return NULL; + winmove( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void attachcursor short s short s */ + +static PyObject * +gl_attachcursor(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + if (!getishortarg(args, 2, 0, &arg1)) + return NULL; + if (!getishortarg(args, 2, 1, &arg2)) + return NULL; + attachcursor( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void deflinestyle short s short s */ + +static PyObject * +gl_deflinestyle(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + if (!getishortarg(args, 2, 0, &arg1)) + return NULL; + if (!getishortarg(args, 2, 1, &arg2)) + return NULL; + deflinestyle( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void noise short s short s */ + +static PyObject * +gl_noise(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + if (!getishortarg(args, 2, 0, &arg1)) + return NULL; + if (!getishortarg(args, 2, 1, &arg2)) + return NULL; + noise( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void picksize short s short s */ + +static PyObject * +gl_picksize(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + if (!getishortarg(args, 2, 0, &arg1)) + return NULL; + if (!getishortarg(args, 2, 1, &arg2)) + return NULL; + picksize( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void qenter short s short s */ + +static PyObject * +gl_qenter(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + if (!getishortarg(args, 2, 0, &arg1)) + return NULL; + if (!getishortarg(args, 2, 1, &arg2)) + return NULL; + qenter( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void setdepth short s short s */ + +static PyObject * +gl_setdepth(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + if (!getishortarg(args, 2, 0, &arg1)) + return NULL; + if (!getishortarg(args, 2, 1, &arg2)) + return NULL; + setdepth( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void cmov2s short s short s */ + +static PyObject * +gl_cmov2s(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + if (!getishortarg(args, 2, 0, &arg1)) + return NULL; + if (!getishortarg(args, 2, 1, &arg2)) + return NULL; + cmov2s( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void draw2s short s short s */ + +static PyObject * +gl_draw2s(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + if (!getishortarg(args, 2, 0, &arg1)) + return NULL; + if (!getishortarg(args, 2, 1, &arg2)) + return NULL; + draw2s( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void move2s short s short s */ + +static PyObject * +gl_move2s(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + if (!getishortarg(args, 2, 0, &arg1)) + return NULL; + if (!getishortarg(args, 2, 1, &arg2)) + return NULL; + move2s( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void pdr2s short s short s */ + +static PyObject * +gl_pdr2s(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + if (!getishortarg(args, 2, 0, &arg1)) + return NULL; + if (!getishortarg(args, 2, 1, &arg2)) + return NULL; + pdr2s( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void pmv2s short s short s */ + +static PyObject * +gl_pmv2s(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + if (!getishortarg(args, 2, 0, &arg1)) + return NULL; + if (!getishortarg(args, 2, 1, &arg2)) + return NULL; + pmv2s( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void pnt2s short s short s */ + +static PyObject * +gl_pnt2s(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + if (!getishortarg(args, 2, 0, &arg1)) + return NULL; + if (!getishortarg(args, 2, 1, &arg2)) + return NULL; + pnt2s( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void rdr2s short s short s */ + +static PyObject * +gl_rdr2s(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + if (!getishortarg(args, 2, 0, &arg1)) + return NULL; + if (!getishortarg(args, 2, 1, &arg2)) + return NULL; + rdr2s( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void rmv2s short s short s */ + +static PyObject * +gl_rmv2s(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + if (!getishortarg(args, 2, 0, &arg1)) + return NULL; + if (!getishortarg(args, 2, 1, &arg2)) + return NULL; + rmv2s( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void rpdr2s short s short s */ + +static PyObject * +gl_rpdr2s(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + if (!getishortarg(args, 2, 0, &arg1)) + return NULL; + if (!getishortarg(args, 2, 1, &arg2)) + return NULL; + rpdr2s( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void rpmv2s short s short s */ + +static PyObject * +gl_rpmv2s(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + if (!getishortarg(args, 2, 0, &arg1)) + return NULL; + if (!getishortarg(args, 2, 1, &arg2)) + return NULL; + rpmv2s( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void xfpt2s short s short s */ + +static PyObject * +gl_xfpt2s(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + if (!getishortarg(args, 2, 0, &arg1)) + return NULL; + if (!getishortarg(args, 2, 1, &arg2)) + return NULL; + xfpt2s( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void cmov2 float s float s */ + +static PyObject * +gl_cmov2(PyObject *self, PyObject *args) +{ + float arg1 ; + float arg2 ; + if (!getifloatarg(args, 2, 0, &arg1)) + return NULL; + if (!getifloatarg(args, 2, 1, &arg2)) + return NULL; + cmov2( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void draw2 float s float s */ + +static PyObject * +gl_draw2(PyObject *self, PyObject *args) +{ + float arg1 ; + float arg2 ; + if (!getifloatarg(args, 2, 0, &arg1)) + return NULL; + if (!getifloatarg(args, 2, 1, &arg2)) + return NULL; + draw2( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void move2 float s float s */ + +static PyObject * +gl_move2(PyObject *self, PyObject *args) +{ + float arg1 ; + float arg2 ; + if (!getifloatarg(args, 2, 0, &arg1)) + return NULL; + if (!getifloatarg(args, 2, 1, &arg2)) + return NULL; + move2( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void pnt2 float s float s */ + +static PyObject * +gl_pnt2(PyObject *self, PyObject *args) +{ + float arg1 ; + float arg2 ; + if (!getifloatarg(args, 2, 0, &arg1)) + return NULL; + if (!getifloatarg(args, 2, 1, &arg2)) + return NULL; + pnt2( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void pdr2 float s float s */ + +static PyObject * +gl_pdr2(PyObject *self, PyObject *args) +{ + float arg1 ; + float arg2 ; + if (!getifloatarg(args, 2, 0, &arg1)) + return NULL; + if (!getifloatarg(args, 2, 1, &arg2)) + return NULL; + pdr2( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void pmv2 float s float s */ + +static PyObject * +gl_pmv2(PyObject *self, PyObject *args) +{ + float arg1 ; + float arg2 ; + if (!getifloatarg(args, 2, 0, &arg1)) + return NULL; + if (!getifloatarg(args, 2, 1, &arg2)) + return NULL; + pmv2( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void rdr2 float s float s */ + +static PyObject * +gl_rdr2(PyObject *self, PyObject *args) +{ + float arg1 ; + float arg2 ; + if (!getifloatarg(args, 2, 0, &arg1)) + return NULL; + if (!getifloatarg(args, 2, 1, &arg2)) + return NULL; + rdr2( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void rmv2 float s float s */ + +static PyObject * +gl_rmv2(PyObject *self, PyObject *args) +{ + float arg1 ; + float arg2 ; + if (!getifloatarg(args, 2, 0, &arg1)) + return NULL; + if (!getifloatarg(args, 2, 1, &arg2)) + return NULL; + rmv2( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void rpdr2 float s float s */ + +static PyObject * +gl_rpdr2(PyObject *self, PyObject *args) +{ + float arg1 ; + float arg2 ; + if (!getifloatarg(args, 2, 0, &arg1)) + return NULL; + if (!getifloatarg(args, 2, 1, &arg2)) + return NULL; + rpdr2( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void rpmv2 float s float s */ + +static PyObject * +gl_rpmv2(PyObject *self, PyObject *args) +{ + float arg1 ; + float arg2 ; + if (!getifloatarg(args, 2, 0, &arg1)) + return NULL; + if (!getifloatarg(args, 2, 1, &arg2)) + return NULL; + rpmv2( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void xfpt2 float s float s */ + +static PyObject * +gl_xfpt2(PyObject *self, PyObject *args) +{ + float arg1 ; + float arg2 ; + if (!getifloatarg(args, 2, 0, &arg1)) + return NULL; + if (!getifloatarg(args, 2, 1, &arg2)) + return NULL; + xfpt2( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void loadmatrix float s[4*4] */ + +static PyObject * +gl_loadmatrix(PyObject *self, PyObject *args) +{ + float arg1 [ 4 ] [ 4 ] ; + if (!getifloatarray(args, 1, 0, 4 * 4 , (float *) arg1)) + return NULL; + loadmatrix( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void multmatrix float s[4*4] */ + +static PyObject * +gl_multmatrix(PyObject *self, PyObject *args) +{ + float arg1 [ 4 ] [ 4 ] ; + if (!getifloatarray(args, 1, 0, 4 * 4 , (float *) arg1)) + return NULL; + multmatrix( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void crv float s[3*4] */ + +static PyObject * +gl_crv(PyObject *self, PyObject *args) +{ + float arg1 [ 4 ] [ 3 ] ; + if (!getifloatarray(args, 1, 0, 3 * 4 , (float *) arg1)) + return NULL; + crv( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void rcrv float s[4*4] */ + +static PyObject * +gl_rcrv(PyObject *self, PyObject *args) +{ + float arg1 [ 4 ] [ 4 ] ; + if (!getifloatarray(args, 1, 0, 4 * 4 , (float *) arg1)) + return NULL; + rcrv( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void addtopup long s char *s long s */ + +static PyObject * +gl_addtopup(PyObject *self, PyObject *args) +{ + long arg1 ; + string arg2 ; + long arg3 ; + if (!getilongarg(args, 3, 0, &arg1)) + return NULL; + if (!getistringarg(args, 3, 1, &arg2)) + return NULL; + if (!getilongarg(args, 3, 2, &arg3)) + return NULL; + addtopup( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void charstr char *s */ + +static PyObject * +gl_charstr(PyObject *self, PyObject *args) +{ + string arg1 ; + if (!getistringarg(args, 1, 0, &arg1)) + return NULL; + charstr( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void getport char *s */ + +static PyObject * +gl_getport(PyObject *self, PyObject *args) +{ + string arg1 ; + if (!getistringarg(args, 1, 0, &arg1)) + return NULL; + getport( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* long strwidth char *s */ + +static PyObject * +gl_strwidth(PyObject *self, PyObject *args) +{ + long retval; + string arg1 ; + if (!getistringarg(args, 1, 0, &arg1)) + return NULL; + retval = strwidth( arg1 ); + return mknewlongobject(retval); +} + +/* long winopen char *s */ + +static PyObject * +gl_winopen(PyObject *self, PyObject *args) +{ + long retval; + string arg1 ; + if (!getistringarg(args, 1, 0, &arg1)) + return NULL; + retval = winopen( arg1 ); + return mknewlongobject(retval); +} + +/* void wintitle char *s */ + +static PyObject * +gl_wintitle(PyObject *self, PyObject *args) +{ + string arg1 ; + if (!getistringarg(args, 1, 0, &arg1)) + return NULL; + wintitle( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void polf long s float s[3*arg1] */ + +static PyObject * +gl_polf(PyObject *self, PyObject *args) +{ + long arg1 ; + float (* arg2) [ 3 ] ; + if (!getilongarraysize(args, 1, 0, &arg1)) + return NULL; + arg1 = arg1 / 3; + if ((arg2 = (float(*)[3]) PyMem_NEW(float , 3 * arg1 )) == NULL) + return PyErr_NoMemory(); + if (!getifloatarray(args, 1, 0, 3 * arg1 , (float *) arg2)) + return NULL; + polf( arg1 , arg2 ); + PyMem_DEL(arg2); + Py_INCREF(Py_None); + return Py_None; +} + +/* void polf2 long s float s[2*arg1] */ + +static PyObject * +gl_polf2(PyObject *self, PyObject *args) +{ + long arg1 ; + float (* arg2) [ 2 ] ; + if (!getilongarraysize(args, 1, 0, &arg1)) + return NULL; + arg1 = arg1 / 2; + if ((arg2 = (float(*)[2]) PyMem_NEW(float , 2 * arg1 )) == NULL) + return PyErr_NoMemory(); + if (!getifloatarray(args, 1, 0, 2 * arg1 , (float *) arg2)) + return NULL; + polf2( arg1 , arg2 ); + PyMem_DEL(arg2); + Py_INCREF(Py_None); + return Py_None; +} + +/* void poly long s float s[3*arg1] */ + +static PyObject * +gl_poly(PyObject *self, PyObject *args) +{ + long arg1 ; + float (* arg2) [ 3 ] ; + if (!getilongarraysize(args, 1, 0, &arg1)) + return NULL; + arg1 = arg1 / 3; + if ((arg2 = (float(*)[3]) PyMem_NEW(float , 3 * arg1 )) == NULL) + return PyErr_NoMemory(); + if (!getifloatarray(args, 1, 0, 3 * arg1 , (float *) arg2)) + return NULL; + poly( arg1 , arg2 ); + PyMem_DEL(arg2); + Py_INCREF(Py_None); + return Py_None; +} + +/* void poly2 long s float s[2*arg1] */ + +static PyObject * +gl_poly2(PyObject *self, PyObject *args) +{ + long arg1 ; + float (* arg2) [ 2 ] ; + if (!getilongarraysize(args, 1, 0, &arg1)) + return NULL; + arg1 = arg1 / 2; + if ((arg2 = (float(*)[2]) PyMem_NEW(float , 2 * arg1 )) == NULL) + return PyErr_NoMemory(); + if (!getifloatarray(args, 1, 0, 2 * arg1 , (float *) arg2)) + return NULL; + poly2( arg1 , arg2 ); + PyMem_DEL(arg2); + Py_INCREF(Py_None); + return Py_None; +} + +/* void crvn long s float s[3*arg1] */ + +static PyObject * +gl_crvn(PyObject *self, PyObject *args) +{ + long arg1 ; + float (* arg2) [ 3 ] ; + if (!getilongarraysize(args, 1, 0, &arg1)) + return NULL; + arg1 = arg1 / 3; + if ((arg2 = (float(*)[3]) PyMem_NEW(float , 3 * arg1 )) == NULL) + return PyErr_NoMemory(); + if (!getifloatarray(args, 1, 0, 3 * arg1 , (float *) arg2)) + return NULL; + crvn( arg1 , arg2 ); + PyMem_DEL(arg2); + Py_INCREF(Py_None); + return Py_None; +} + +/* void rcrvn long s float s[4*arg1] */ + +static PyObject * +gl_rcrvn(PyObject *self, PyObject *args) +{ + long arg1 ; + float (* arg2) [ 4 ] ; + if (!getilongarraysize(args, 1, 0, &arg1)) + return NULL; + arg1 = arg1 / 4; + if ((arg2 = (float(*)[4]) PyMem_NEW(float , 4 * arg1 )) == NULL) + return PyErr_NoMemory(); + if (!getifloatarray(args, 1, 0, 4 * arg1 , (float *) arg2)) + return NULL; + rcrvn( arg1 , arg2 ); + PyMem_DEL(arg2); + Py_INCREF(Py_None); + return Py_None; +} + +/* void polf2i long s long s[2*arg1] */ + +static PyObject * +gl_polf2i(PyObject *self, PyObject *args) +{ + long arg1 ; + long (* arg2) [ 2 ] ; + if (!getilongarraysize(args, 1, 0, &arg1)) + return NULL; + arg1 = arg1 / 2; + if ((arg2 = (long(*)[2]) PyMem_NEW(long , 2 * arg1 )) == NULL) + return PyErr_NoMemory(); + if (!getilongarray(args, 1, 0, 2 * arg1 , (long *) arg2)) + return NULL; + polf2i( arg1 , arg2 ); + PyMem_DEL(arg2); + Py_INCREF(Py_None); + return Py_None; +} + +/* void polfi long s long s[3*arg1] */ + +static PyObject * +gl_polfi(PyObject *self, PyObject *args) +{ + long arg1 ; + long (* arg2) [ 3 ] ; + if (!getilongarraysize(args, 1, 0, &arg1)) + return NULL; + arg1 = arg1 / 3; + if ((arg2 = (long(*)[3]) PyMem_NEW(long , 3 * arg1 )) == NULL) + return PyErr_NoMemory(); + if (!getilongarray(args, 1, 0, 3 * arg1 , (long *) arg2)) + return NULL; + polfi( arg1 , arg2 ); + PyMem_DEL(arg2); + Py_INCREF(Py_None); + return Py_None; +} + +/* void poly2i long s long s[2*arg1] */ + +static PyObject * +gl_poly2i(PyObject *self, PyObject *args) +{ + long arg1 ; + long (* arg2) [ 2 ] ; + if (!getilongarraysize(args, 1, 0, &arg1)) + return NULL; + arg1 = arg1 / 2; + if ((arg2 = (long(*)[2]) PyMem_NEW(long , 2 * arg1 )) == NULL) + return PyErr_NoMemory(); + if (!getilongarray(args, 1, 0, 2 * arg1 , (long *) arg2)) + return NULL; + poly2i( arg1 , arg2 ); + PyMem_DEL(arg2); + Py_INCREF(Py_None); + return Py_None; +} + +/* void polyi long s long s[3*arg1] */ + +static PyObject * +gl_polyi(PyObject *self, PyObject *args) +{ + long arg1 ; + long (* arg2) [ 3 ] ; + if (!getilongarraysize(args, 1, 0, &arg1)) + return NULL; + arg1 = arg1 / 3; + if ((arg2 = (long(*)[3]) PyMem_NEW(long , 3 * arg1 )) == NULL) + return PyErr_NoMemory(); + if (!getilongarray(args, 1, 0, 3 * arg1 , (long *) arg2)) + return NULL; + polyi( arg1 , arg2 ); + PyMem_DEL(arg2); + Py_INCREF(Py_None); + return Py_None; +} + +/* void polf2s long s short s[2*arg1] */ + +static PyObject * +gl_polf2s(PyObject *self, PyObject *args) +{ + long arg1 ; + short (* arg2) [ 2 ] ; + if (!getilongarraysize(args, 1, 0, &arg1)) + return NULL; + arg1 = arg1 / 2; + if ((arg2 = (short(*)[2]) PyMem_NEW(short , 2 * arg1 )) == NULL) + return PyErr_NoMemory(); + if (!getishortarray(args, 1, 0, 2 * arg1 , (short *) arg2)) + return NULL; + polf2s( arg1 , arg2 ); + PyMem_DEL(arg2); + Py_INCREF(Py_None); + return Py_None; +} + +/* void polfs long s short s[3*arg1] */ + +static PyObject * +gl_polfs(PyObject *self, PyObject *args) +{ + long arg1 ; + short (* arg2) [ 3 ] ; + if (!getilongarraysize(args, 1, 0, &arg1)) + return NULL; + arg1 = arg1 / 3; + if ((arg2 = (short(*)[3]) PyMem_NEW(short , 3 * arg1 )) == NULL) + return PyErr_NoMemory(); + if (!getishortarray(args, 1, 0, 3 * arg1 , (short *) arg2)) + return NULL; + polfs( arg1 , arg2 ); + PyMem_DEL(arg2); + Py_INCREF(Py_None); + return Py_None; +} + +/* void polys long s short s[3*arg1] */ + +static PyObject * +gl_polys(PyObject *self, PyObject *args) +{ + long arg1 ; + short (* arg2) [ 3 ] ; + if (!getilongarraysize(args, 1, 0, &arg1)) + return NULL; + arg1 = arg1 / 3; + if ((arg2 = (short(*)[3]) PyMem_NEW(short , 3 * arg1 )) == NULL) + return PyErr_NoMemory(); + if (!getishortarray(args, 1, 0, 3 * arg1 , (short *) arg2)) + return NULL; + polys( arg1 , arg2 ); + PyMem_DEL(arg2); + Py_INCREF(Py_None); + return Py_None; +} + +/* void poly2s long s short s[2*arg1] */ + +static PyObject * +gl_poly2s(PyObject *self, PyObject *args) +{ + long arg1 ; + short (* arg2) [ 2 ] ; + if (!getilongarraysize(args, 1, 0, &arg1)) + return NULL; + arg1 = arg1 / 2; + if ((arg2 = (short(*)[2]) PyMem_NEW(short , 2 * arg1 )) == NULL) + return PyErr_NoMemory(); + if (!getishortarray(args, 1, 0, 2 * arg1 , (short *) arg2)) + return NULL; + poly2s( arg1 , arg2 ); + PyMem_DEL(arg2); + Py_INCREF(Py_None); + return Py_None; +} + +/* void defcursor short s u_short s[128] */ + +static PyObject * +gl_defcursor(PyObject *self, PyObject *args) +{ + short arg1 ; + unsigned short arg2 [ 128 ] ; + if (!getishortarg(args, 2, 0, &arg1)) + return NULL; + if (!getishortarray(args, 2, 1, 128 , (short *) arg2)) + return NULL; + defcursor( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void writepixels short s u_short s[arg1] */ + +static PyObject * +gl_writepixels(PyObject *self, PyObject *args) +{ + short arg1 ; + unsigned short * arg2 ; + if (!getishortarraysize(args, 1, 0, &arg1)) + return NULL; + if ((arg2 = PyMem_NEW(unsigned short , arg1 )) == NULL) + return PyErr_NoMemory(); + if (!getishortarray(args, 1, 0, arg1 , (short *) arg2)) + return NULL; + writepixels( arg1 , arg2 ); + PyMem_DEL(arg2); + Py_INCREF(Py_None); + return Py_None; +} + +/* void defbasis long s float s[4*4] */ + +static PyObject * +gl_defbasis(PyObject *self, PyObject *args) +{ + long arg1 ; + float arg2 [ 4 ] [ 4 ] ; + if (!getilongarg(args, 2, 0, &arg1)) + return NULL; + if (!getifloatarray(args, 2, 1, 4 * 4 , (float *) arg2)) + return NULL; + defbasis( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void gewrite short s short s[arg1] */ + +static PyObject * +gl_gewrite(PyObject *self, PyObject *args) +{ + short arg1 ; + short * arg2 ; + if (!getishortarraysize(args, 1, 0, &arg1)) + return NULL; + if ((arg2 = PyMem_NEW(short , arg1 )) == NULL) + return PyErr_NoMemory(); + if (!getishortarray(args, 1, 0, arg1 , arg2)) + return NULL; + gewrite( arg1 , arg2 ); + PyMem_DEL(arg2); + Py_INCREF(Py_None); + return Py_None; +} + +/* void rotate short s char s */ + +static PyObject * +gl_rotate(PyObject *self, PyObject *args) +{ + short arg1 ; + char arg2 ; + if (!getishortarg(args, 2, 0, &arg1)) + return NULL; + if (!getichararg(args, 2, 1, &arg2)) + return NULL; + rotate( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void rot float s char s */ + +static PyObject * +gl_rot(PyObject *self, PyObject *args) +{ + float arg1 ; + char arg2 ; + if (!getifloatarg(args, 2, 0, &arg1)) + return NULL; + if (!getichararg(args, 2, 1, &arg2)) + return NULL; + rot( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void circfi long s long s long s */ + +static PyObject * +gl_circfi(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + long arg3 ; + if (!getilongarg(args, 3, 0, &arg1)) + return NULL; + if (!getilongarg(args, 3, 1, &arg2)) + return NULL; + if (!getilongarg(args, 3, 2, &arg3)) + return NULL; + circfi( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void circi long s long s long s */ + +static PyObject * +gl_circi(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + long arg3 ; + if (!getilongarg(args, 3, 0, &arg1)) + return NULL; + if (!getilongarg(args, 3, 1, &arg2)) + return NULL; + if (!getilongarg(args, 3, 2, &arg3)) + return NULL; + circi( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void cmovi long s long s long s */ + +static PyObject * +gl_cmovi(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + long arg3 ; + if (!getilongarg(args, 3, 0, &arg1)) + return NULL; + if (!getilongarg(args, 3, 1, &arg2)) + return NULL; + if (!getilongarg(args, 3, 2, &arg3)) + return NULL; + cmovi( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void drawi long s long s long s */ + +static PyObject * +gl_drawi(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + long arg3 ; + if (!getilongarg(args, 3, 0, &arg1)) + return NULL; + if (!getilongarg(args, 3, 1, &arg2)) + return NULL; + if (!getilongarg(args, 3, 2, &arg3)) + return NULL; + drawi( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void movei long s long s long s */ + +static PyObject * +gl_movei(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + long arg3 ; + if (!getilongarg(args, 3, 0, &arg1)) + return NULL; + if (!getilongarg(args, 3, 1, &arg2)) + return NULL; + if (!getilongarg(args, 3, 2, &arg3)) + return NULL; + movei( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void pnti long s long s long s */ + +static PyObject * +gl_pnti(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + long arg3 ; + if (!getilongarg(args, 3, 0, &arg1)) + return NULL; + if (!getilongarg(args, 3, 1, &arg2)) + return NULL; + if (!getilongarg(args, 3, 2, &arg3)) + return NULL; + pnti( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void newtag long s long s long s */ + +static PyObject * +gl_newtag(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + long arg3 ; + if (!getilongarg(args, 3, 0, &arg1)) + return NULL; + if (!getilongarg(args, 3, 1, &arg2)) + return NULL; + if (!getilongarg(args, 3, 2, &arg3)) + return NULL; + newtag( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void pdri long s long s long s */ + +static PyObject * +gl_pdri(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + long arg3 ; + if (!getilongarg(args, 3, 0, &arg1)) + return NULL; + if (!getilongarg(args, 3, 1, &arg2)) + return NULL; + if (!getilongarg(args, 3, 2, &arg3)) + return NULL; + pdri( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void pmvi long s long s long s */ + +static PyObject * +gl_pmvi(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + long arg3 ; + if (!getilongarg(args, 3, 0, &arg1)) + return NULL; + if (!getilongarg(args, 3, 1, &arg2)) + return NULL; + if (!getilongarg(args, 3, 2, &arg3)) + return NULL; + pmvi( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void rdri long s long s long s */ + +static PyObject * +gl_rdri(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + long arg3 ; + if (!getilongarg(args, 3, 0, &arg1)) + return NULL; + if (!getilongarg(args, 3, 1, &arg2)) + return NULL; + if (!getilongarg(args, 3, 2, &arg3)) + return NULL; + rdri( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void rmvi long s long s long s */ + +static PyObject * +gl_rmvi(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + long arg3 ; + if (!getilongarg(args, 3, 0, &arg1)) + return NULL; + if (!getilongarg(args, 3, 1, &arg2)) + return NULL; + if (!getilongarg(args, 3, 2, &arg3)) + return NULL; + rmvi( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void rpdri long s long s long s */ + +static PyObject * +gl_rpdri(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + long arg3 ; + if (!getilongarg(args, 3, 0, &arg1)) + return NULL; + if (!getilongarg(args, 3, 1, &arg2)) + return NULL; + if (!getilongarg(args, 3, 2, &arg3)) + return NULL; + rpdri( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void rpmvi long s long s long s */ + +static PyObject * +gl_rpmvi(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + long arg3 ; + if (!getilongarg(args, 3, 0, &arg1)) + return NULL; + if (!getilongarg(args, 3, 1, &arg2)) + return NULL; + if (!getilongarg(args, 3, 2, &arg3)) + return NULL; + rpmvi( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void xfpti long s long s long s */ + +static PyObject * +gl_xfpti(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + long arg3 ; + if (!getilongarg(args, 3, 0, &arg1)) + return NULL; + if (!getilongarg(args, 3, 1, &arg2)) + return NULL; + if (!getilongarg(args, 3, 2, &arg3)) + return NULL; + xfpti( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void circ float s float s float s */ + +static PyObject * +gl_circ(PyObject *self, PyObject *args) +{ + float arg1 ; + float arg2 ; + float arg3 ; + if (!getifloatarg(args, 3, 0, &arg1)) + return NULL; + if (!getifloatarg(args, 3, 1, &arg2)) + return NULL; + if (!getifloatarg(args, 3, 2, &arg3)) + return NULL; + circ( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void circf float s float s float s */ + +static PyObject * +gl_circf(PyObject *self, PyObject *args) +{ + float arg1 ; + float arg2 ; + float arg3 ; + if (!getifloatarg(args, 3, 0, &arg1)) + return NULL; + if (!getifloatarg(args, 3, 1, &arg2)) + return NULL; + if (!getifloatarg(args, 3, 2, &arg3)) + return NULL; + circf( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void cmov float s float s float s */ + +static PyObject * +gl_cmov(PyObject *self, PyObject *args) +{ + float arg1 ; + float arg2 ; + float arg3 ; + if (!getifloatarg(args, 3, 0, &arg1)) + return NULL; + if (!getifloatarg(args, 3, 1, &arg2)) + return NULL; + if (!getifloatarg(args, 3, 2, &arg3)) + return NULL; + cmov( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void draw float s float s float s */ + +static PyObject * +gl_draw(PyObject *self, PyObject *args) +{ + float arg1 ; + float arg2 ; + float arg3 ; + if (!getifloatarg(args, 3, 0, &arg1)) + return NULL; + if (!getifloatarg(args, 3, 1, &arg2)) + return NULL; + if (!getifloatarg(args, 3, 2, &arg3)) + return NULL; + draw( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void move float s float s float s */ + +static PyObject * +gl_move(PyObject *self, PyObject *args) +{ + float arg1 ; + float arg2 ; + float arg3 ; + if (!getifloatarg(args, 3, 0, &arg1)) + return NULL; + if (!getifloatarg(args, 3, 1, &arg2)) + return NULL; + if (!getifloatarg(args, 3, 2, &arg3)) + return NULL; + move( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void pnt float s float s float s */ + +static PyObject * +gl_pnt(PyObject *self, PyObject *args) +{ + float arg1 ; + float arg2 ; + float arg3 ; + if (!getifloatarg(args, 3, 0, &arg1)) + return NULL; + if (!getifloatarg(args, 3, 1, &arg2)) + return NULL; + if (!getifloatarg(args, 3, 2, &arg3)) + return NULL; + pnt( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void scale float s float s float s */ + +static PyObject * +gl_scale(PyObject *self, PyObject *args) +{ + float arg1 ; + float arg2 ; + float arg3 ; + if (!getifloatarg(args, 3, 0, &arg1)) + return NULL; + if (!getifloatarg(args, 3, 1, &arg2)) + return NULL; + if (!getifloatarg(args, 3, 2, &arg3)) + return NULL; + scale( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void translate float s float s float s */ + +static PyObject * +gl_translate(PyObject *self, PyObject *args) +{ + float arg1 ; + float arg2 ; + float arg3 ; + if (!getifloatarg(args, 3, 0, &arg1)) + return NULL; + if (!getifloatarg(args, 3, 1, &arg2)) + return NULL; + if (!getifloatarg(args, 3, 2, &arg3)) + return NULL; + translate( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void pdr float s float s float s */ + +static PyObject * +gl_pdr(PyObject *self, PyObject *args) +{ + float arg1 ; + float arg2 ; + float arg3 ; + if (!getifloatarg(args, 3, 0, &arg1)) + return NULL; + if (!getifloatarg(args, 3, 1, &arg2)) + return NULL; + if (!getifloatarg(args, 3, 2, &arg3)) + return NULL; + pdr( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void pmv float s float s float s */ + +static PyObject * +gl_pmv(PyObject *self, PyObject *args) +{ + float arg1 ; + float arg2 ; + float arg3 ; + if (!getifloatarg(args, 3, 0, &arg1)) + return NULL; + if (!getifloatarg(args, 3, 1, &arg2)) + return NULL; + if (!getifloatarg(args, 3, 2, &arg3)) + return NULL; + pmv( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void rdr float s float s float s */ + +static PyObject * +gl_rdr(PyObject *self, PyObject *args) +{ + float arg1 ; + float arg2 ; + float arg3 ; + if (!getifloatarg(args, 3, 0, &arg1)) + return NULL; + if (!getifloatarg(args, 3, 1, &arg2)) + return NULL; + if (!getifloatarg(args, 3, 2, &arg3)) + return NULL; + rdr( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void rmv float s float s float s */ + +static PyObject * +gl_rmv(PyObject *self, PyObject *args) +{ + float arg1 ; + float arg2 ; + float arg3 ; + if (!getifloatarg(args, 3, 0, &arg1)) + return NULL; + if (!getifloatarg(args, 3, 1, &arg2)) + return NULL; + if (!getifloatarg(args, 3, 2, &arg3)) + return NULL; + rmv( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void rpdr float s float s float s */ + +static PyObject * +gl_rpdr(PyObject *self, PyObject *args) +{ + float arg1 ; + float arg2 ; + float arg3 ; + if (!getifloatarg(args, 3, 0, &arg1)) + return NULL; + if (!getifloatarg(args, 3, 1, &arg2)) + return NULL; + if (!getifloatarg(args, 3, 2, &arg3)) + return NULL; + rpdr( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void rpmv float s float s float s */ + +static PyObject * +gl_rpmv(PyObject *self, PyObject *args) +{ + float arg1 ; + float arg2 ; + float arg3 ; + if (!getifloatarg(args, 3, 0, &arg1)) + return NULL; + if (!getifloatarg(args, 3, 1, &arg2)) + return NULL; + if (!getifloatarg(args, 3, 2, &arg3)) + return NULL; + rpmv( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void xfpt float s float s float s */ + +static PyObject * +gl_xfpt(PyObject *self, PyObject *args) +{ + float arg1 ; + float arg2 ; + float arg3 ; + if (!getifloatarg(args, 3, 0, &arg1)) + return NULL; + if (!getifloatarg(args, 3, 1, &arg2)) + return NULL; + if (!getifloatarg(args, 3, 2, &arg3)) + return NULL; + xfpt( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void RGBcolor short s short s short s */ + +static PyObject * +gl_RGBcolor(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + if (!getishortarg(args, 3, 0, &arg1)) + return NULL; + if (!getishortarg(args, 3, 1, &arg2)) + return NULL; + if (!getishortarg(args, 3, 2, &arg3)) + return NULL; + RGBcolor( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void RGBwritemask short s short s short s */ + +static PyObject * +gl_RGBwritemask(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + if (!getishortarg(args, 3, 0, &arg1)) + return NULL; + if (!getishortarg(args, 3, 1, &arg2)) + return NULL; + if (!getishortarg(args, 3, 2, &arg3)) + return NULL; + RGBwritemask( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void setcursor short s short s short s */ + +static PyObject * +gl_setcursor(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + if (!getishortarg(args, 3, 0, &arg1)) + return NULL; + if (!getishortarg(args, 3, 1, &arg2)) + return NULL; + if (!getishortarg(args, 3, 2, &arg3)) + return NULL; + setcursor( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void tie short s short s short s */ + +static PyObject * +gl_tie(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + if (!getishortarg(args, 3, 0, &arg1)) + return NULL; + if (!getishortarg(args, 3, 1, &arg2)) + return NULL; + if (!getishortarg(args, 3, 2, &arg3)) + return NULL; + tie( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void circfs short s short s short s */ + +static PyObject * +gl_circfs(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + if (!getishortarg(args, 3, 0, &arg1)) + return NULL; + if (!getishortarg(args, 3, 1, &arg2)) + return NULL; + if (!getishortarg(args, 3, 2, &arg3)) + return NULL; + circfs( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void circs short s short s short s */ + +static PyObject * +gl_circs(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + if (!getishortarg(args, 3, 0, &arg1)) + return NULL; + if (!getishortarg(args, 3, 1, &arg2)) + return NULL; + if (!getishortarg(args, 3, 2, &arg3)) + return NULL; + circs( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void cmovs short s short s short s */ + +static PyObject * +gl_cmovs(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + if (!getishortarg(args, 3, 0, &arg1)) + return NULL; + if (!getishortarg(args, 3, 1, &arg2)) + return NULL; + if (!getishortarg(args, 3, 2, &arg3)) + return NULL; + cmovs( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void draws short s short s short s */ + +static PyObject * +gl_draws(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + if (!getishortarg(args, 3, 0, &arg1)) + return NULL; + if (!getishortarg(args, 3, 1, &arg2)) + return NULL; + if (!getishortarg(args, 3, 2, &arg3)) + return NULL; + draws( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void moves short s short s short s */ + +static PyObject * +gl_moves(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + if (!getishortarg(args, 3, 0, &arg1)) + return NULL; + if (!getishortarg(args, 3, 1, &arg2)) + return NULL; + if (!getishortarg(args, 3, 2, &arg3)) + return NULL; + moves( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void pdrs short s short s short s */ + +static PyObject * +gl_pdrs(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + if (!getishortarg(args, 3, 0, &arg1)) + return NULL; + if (!getishortarg(args, 3, 1, &arg2)) + return NULL; + if (!getishortarg(args, 3, 2, &arg3)) + return NULL; + pdrs( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void pmvs short s short s short s */ + +static PyObject * +gl_pmvs(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + if (!getishortarg(args, 3, 0, &arg1)) + return NULL; + if (!getishortarg(args, 3, 1, &arg2)) + return NULL; + if (!getishortarg(args, 3, 2, &arg3)) + return NULL; + pmvs( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void pnts short s short s short s */ + +static PyObject * +gl_pnts(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + if (!getishortarg(args, 3, 0, &arg1)) + return NULL; + if (!getishortarg(args, 3, 1, &arg2)) + return NULL; + if (!getishortarg(args, 3, 2, &arg3)) + return NULL; + pnts( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void rdrs short s short s short s */ + +static PyObject * +gl_rdrs(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + if (!getishortarg(args, 3, 0, &arg1)) + return NULL; + if (!getishortarg(args, 3, 1, &arg2)) + return NULL; + if (!getishortarg(args, 3, 2, &arg3)) + return NULL; + rdrs( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void rmvs short s short s short s */ + +static PyObject * +gl_rmvs(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + if (!getishortarg(args, 3, 0, &arg1)) + return NULL; + if (!getishortarg(args, 3, 1, &arg2)) + return NULL; + if (!getishortarg(args, 3, 2, &arg3)) + return NULL; + rmvs( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void rpdrs short s short s short s */ + +static PyObject * +gl_rpdrs(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + if (!getishortarg(args, 3, 0, &arg1)) + return NULL; + if (!getishortarg(args, 3, 1, &arg2)) + return NULL; + if (!getishortarg(args, 3, 2, &arg3)) + return NULL; + rpdrs( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void rpmvs short s short s short s */ + +static PyObject * +gl_rpmvs(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + if (!getishortarg(args, 3, 0, &arg1)) + return NULL; + if (!getishortarg(args, 3, 1, &arg2)) + return NULL; + if (!getishortarg(args, 3, 2, &arg3)) + return NULL; + rpmvs( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void xfpts short s short s short s */ + +static PyObject * +gl_xfpts(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + if (!getishortarg(args, 3, 0, &arg1)) + return NULL; + if (!getishortarg(args, 3, 1, &arg2)) + return NULL; + if (!getishortarg(args, 3, 2, &arg3)) + return NULL; + xfpts( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void curorigin short s short s short s */ + +static PyObject * +gl_curorigin(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + if (!getishortarg(args, 3, 0, &arg1)) + return NULL; + if (!getishortarg(args, 3, 1, &arg2)) + return NULL; + if (!getishortarg(args, 3, 2, &arg3)) + return NULL; + curorigin( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void cyclemap short s short s short s */ + +static PyObject * +gl_cyclemap(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + if (!getishortarg(args, 3, 0, &arg1)) + return NULL; + if (!getishortarg(args, 3, 1, &arg2)) + return NULL; + if (!getishortarg(args, 3, 2, &arg3)) + return NULL; + cyclemap( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void patch float s[4*4] float s[4*4] float s[4*4] */ + +static PyObject * +gl_patch(PyObject *self, PyObject *args) +{ + float arg1 [ 4 ] [ 4 ] ; + float arg2 [ 4 ] [ 4 ] ; + float arg3 [ 4 ] [ 4 ] ; + if (!getifloatarray(args, 3, 0, 4 * 4 , (float *) arg1)) + return NULL; + if (!getifloatarray(args, 3, 1, 4 * 4 , (float *) arg2)) + return NULL; + if (!getifloatarray(args, 3, 2, 4 * 4 , (float *) arg3)) + return NULL; + patch( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void splf long s float s[3*arg1] u_short s[arg1] */ + +static PyObject * +gl_splf(PyObject *self, PyObject *args) +{ + long arg1 ; + float (* arg2) [ 3 ] ; + unsigned short * arg3 ; + if (!getilongarraysize(args, 2, 0, &arg1)) + return NULL; + arg1 = arg1 / 3; + if ((arg2 = (float(*)[3]) PyMem_NEW(float , 3 * arg1 )) == NULL) + return PyErr_NoMemory(); + if (!getifloatarray(args, 2, 0, 3 * arg1 , (float *) arg2)) + return NULL; + if ((arg3 = PyMem_NEW(unsigned short , arg1 )) == NULL) + return PyErr_NoMemory(); + if (!getishortarray(args, 2, 1, arg1 , (short *) arg3)) + return NULL; + splf( arg1 , arg2 , arg3 ); + PyMem_DEL(arg2); + PyMem_DEL(arg3); + Py_INCREF(Py_None); + return Py_None; +} + +/* void splf2 long s float s[2*arg1] u_short s[arg1] */ + +static PyObject * +gl_splf2(PyObject *self, PyObject *args) +{ + long arg1 ; + float (* arg2) [ 2 ] ; + unsigned short * arg3 ; + if (!getilongarraysize(args, 2, 0, &arg1)) + return NULL; + arg1 = arg1 / 2; + if ((arg2 = (float(*)[2]) PyMem_NEW(float , 2 * arg1 )) == NULL) + return PyErr_NoMemory(); + if (!getifloatarray(args, 2, 0, 2 * arg1 , (float *) arg2)) + return NULL; + if ((arg3 = PyMem_NEW(unsigned short , arg1 )) == NULL) + return PyErr_NoMemory(); + if (!getishortarray(args, 2, 1, arg1 , (short *) arg3)) + return NULL; + splf2( arg1 , arg2 , arg3 ); + PyMem_DEL(arg2); + PyMem_DEL(arg3); + Py_INCREF(Py_None); + return Py_None; +} + +/* void splfi long s long s[3*arg1] u_short s[arg1] */ + +static PyObject * +gl_splfi(PyObject *self, PyObject *args) +{ + long arg1 ; + long (* arg2) [ 3 ] ; + unsigned short * arg3 ; + if (!getilongarraysize(args, 2, 0, &arg1)) + return NULL; + arg1 = arg1 / 3; + if ((arg2 = (long(*)[3]) PyMem_NEW(long , 3 * arg1 )) == NULL) + return PyErr_NoMemory(); + if (!getilongarray(args, 2, 0, 3 * arg1 , (long *) arg2)) + return NULL; + if ((arg3 = PyMem_NEW(unsigned short , arg1 )) == NULL) + return PyErr_NoMemory(); + if (!getishortarray(args, 2, 1, arg1 , (short *) arg3)) + return NULL; + splfi( arg1 , arg2 , arg3 ); + PyMem_DEL(arg2); + PyMem_DEL(arg3); + Py_INCREF(Py_None); + return Py_None; +} + +/* void splf2i long s long s[2*arg1] u_short s[arg1] */ + +static PyObject * +gl_splf2i(PyObject *self, PyObject *args) +{ + long arg1 ; + long (* arg2) [ 2 ] ; + unsigned short * arg3 ; + if (!getilongarraysize(args, 2, 0, &arg1)) + return NULL; + arg1 = arg1 / 2; + if ((arg2 = (long(*)[2]) PyMem_NEW(long , 2 * arg1 )) == NULL) + return PyErr_NoMemory(); + if (!getilongarray(args, 2, 0, 2 * arg1 , (long *) arg2)) + return NULL; + if ((arg3 = PyMem_NEW(unsigned short , arg1 )) == NULL) + return PyErr_NoMemory(); + if (!getishortarray(args, 2, 1, arg1 , (short *) arg3)) + return NULL; + splf2i( arg1 , arg2 , arg3 ); + PyMem_DEL(arg2); + PyMem_DEL(arg3); + Py_INCREF(Py_None); + return Py_None; +} + +/* void splfs long s short s[3*arg1] u_short s[arg1] */ + +static PyObject * +gl_splfs(PyObject *self, PyObject *args) +{ + long arg1 ; + short (* arg2) [ 3 ] ; + unsigned short * arg3 ; + if (!getilongarraysize(args, 2, 0, &arg1)) + return NULL; + arg1 = arg1 / 3; + if ((arg2 = (short(*)[3]) PyMem_NEW(short , 3 * arg1 )) == NULL) + return PyErr_NoMemory(); + if (!getishortarray(args, 2, 0, 3 * arg1 , (short *) arg2)) + return NULL; + if ((arg3 = PyMem_NEW(unsigned short , arg1 )) == NULL) + return PyErr_NoMemory(); + if (!getishortarray(args, 2, 1, arg1 , (short *) arg3)) + return NULL; + splfs( arg1 , arg2 , arg3 ); + PyMem_DEL(arg2); + PyMem_DEL(arg3); + Py_INCREF(Py_None); + return Py_None; +} + +/* void splf2s long s short s[2*arg1] u_short s[arg1] */ + +static PyObject * +gl_splf2s(PyObject *self, PyObject *args) +{ + long arg1 ; + short (* arg2) [ 2 ] ; + unsigned short * arg3 ; + if (!getilongarraysize(args, 2, 0, &arg1)) + return NULL; + arg1 = arg1 / 2; + if ((arg2 = (short(*)[2]) PyMem_NEW(short , 2 * arg1 )) == NULL) + return PyErr_NoMemory(); + if (!getishortarray(args, 2, 0, 2 * arg1 , (short *) arg2)) + return NULL; + if ((arg3 = PyMem_NEW(unsigned short , arg1 )) == NULL) + return PyErr_NoMemory(); + if (!getishortarray(args, 2, 1, arg1 , (short *) arg3)) + return NULL; + splf2s( arg1 , arg2 , arg3 ); + PyMem_DEL(arg2); + PyMem_DEL(arg3); + Py_INCREF(Py_None); + return Py_None; +} + +/* void rpatch float s[4*4] float s[4*4] float s[4*4] float s[4*4] */ + +static PyObject * +gl_rpatch(PyObject *self, PyObject *args) +{ + float arg1 [ 4 ] [ 4 ] ; + float arg2 [ 4 ] [ 4 ] ; + float arg3 [ 4 ] [ 4 ] ; + float arg4 [ 4 ] [ 4 ] ; + if (!getifloatarray(args, 4, 0, 4 * 4 , (float *) arg1)) + return NULL; + if (!getifloatarray(args, 4, 1, 4 * 4 , (float *) arg2)) + return NULL; + if (!getifloatarray(args, 4, 2, 4 * 4 , (float *) arg3)) + return NULL; + if (!getifloatarray(args, 4, 3, 4 * 4 , (float *) arg4)) + return NULL; + rpatch( arg1 , arg2 , arg3 , arg4 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void ortho2 float s float s float s float s */ + +static PyObject * +gl_ortho2(PyObject *self, PyObject *args) +{ + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + if (!getifloatarg(args, 4, 0, &arg1)) + return NULL; + if (!getifloatarg(args, 4, 1, &arg2)) + return NULL; + if (!getifloatarg(args, 4, 2, &arg3)) + return NULL; + if (!getifloatarg(args, 4, 3, &arg4)) + return NULL; + ortho2( arg1 , arg2 , arg3 , arg4 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void rect float s float s float s float s */ + +static PyObject * +gl_rect(PyObject *self, PyObject *args) +{ + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + if (!getifloatarg(args, 4, 0, &arg1)) + return NULL; + if (!getifloatarg(args, 4, 1, &arg2)) + return NULL; + if (!getifloatarg(args, 4, 2, &arg3)) + return NULL; + if (!getifloatarg(args, 4, 3, &arg4)) + return NULL; + rect( arg1 , arg2 , arg3 , arg4 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void rectf float s float s float s float s */ + +static PyObject * +gl_rectf(PyObject *self, PyObject *args) +{ + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + if (!getifloatarg(args, 4, 0, &arg1)) + return NULL; + if (!getifloatarg(args, 4, 1, &arg2)) + return NULL; + if (!getifloatarg(args, 4, 2, &arg3)) + return NULL; + if (!getifloatarg(args, 4, 3, &arg4)) + return NULL; + rectf( arg1 , arg2 , arg3 , arg4 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void xfpt4 float s float s float s float s */ + +static PyObject * +gl_xfpt4(PyObject *self, PyObject *args) +{ + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + if (!getifloatarg(args, 4, 0, &arg1)) + return NULL; + if (!getifloatarg(args, 4, 1, &arg2)) + return NULL; + if (!getifloatarg(args, 4, 2, &arg3)) + return NULL; + if (!getifloatarg(args, 4, 3, &arg4)) + return NULL; + xfpt4( arg1 , arg2 , arg3 , arg4 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void textport short s short s short s short s */ + +static PyObject * +gl_textport(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + short arg4 ; + if (!getishortarg(args, 4, 0, &arg1)) + return NULL; + if (!getishortarg(args, 4, 1, &arg2)) + return NULL; + if (!getishortarg(args, 4, 2, &arg3)) + return NULL; + if (!getishortarg(args, 4, 3, &arg4)) + return NULL; + textport( arg1 , arg2 , arg3 , arg4 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void mapcolor short s short s short s short s */ + +static PyObject * +gl_mapcolor(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + short arg4 ; + if (!getishortarg(args, 4, 0, &arg1)) + return NULL; + if (!getishortarg(args, 4, 1, &arg2)) + return NULL; + if (!getishortarg(args, 4, 2, &arg3)) + return NULL; + if (!getishortarg(args, 4, 3, &arg4)) + return NULL; + mapcolor( arg1 , arg2 , arg3 , arg4 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void scrmask short s short s short s short s */ + +static PyObject * +gl_scrmask(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + short arg4 ; + if (!getishortarg(args, 4, 0, &arg1)) + return NULL; + if (!getishortarg(args, 4, 1, &arg2)) + return NULL; + if (!getishortarg(args, 4, 2, &arg3)) + return NULL; + if (!getishortarg(args, 4, 3, &arg4)) + return NULL; + scrmask( arg1 , arg2 , arg3 , arg4 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void setvaluator short s short s short s short s */ + +static PyObject * +gl_setvaluator(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + short arg4 ; + if (!getishortarg(args, 4, 0, &arg1)) + return NULL; + if (!getishortarg(args, 4, 1, &arg2)) + return NULL; + if (!getishortarg(args, 4, 2, &arg3)) + return NULL; + if (!getishortarg(args, 4, 3, &arg4)) + return NULL; + setvaluator( arg1 , arg2 , arg3 , arg4 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void viewport short s short s short s short s */ + +static PyObject * +gl_viewport(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + short arg4 ; + if (!getishortarg(args, 4, 0, &arg1)) + return NULL; + if (!getishortarg(args, 4, 1, &arg2)) + return NULL; + if (!getishortarg(args, 4, 2, &arg3)) + return NULL; + if (!getishortarg(args, 4, 3, &arg4)) + return NULL; + viewport( arg1 , arg2 , arg3 , arg4 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void shaderange short s short s short s short s */ + +static PyObject * +gl_shaderange(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + short arg4 ; + if (!getishortarg(args, 4, 0, &arg1)) + return NULL; + if (!getishortarg(args, 4, 1, &arg2)) + return NULL; + if (!getishortarg(args, 4, 2, &arg3)) + return NULL; + if (!getishortarg(args, 4, 3, &arg4)) + return NULL; + shaderange( arg1 , arg2 , arg3 , arg4 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void xfpt4s short s short s short s short s */ + +static PyObject * +gl_xfpt4s(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + short arg4 ; + if (!getishortarg(args, 4, 0, &arg1)) + return NULL; + if (!getishortarg(args, 4, 1, &arg2)) + return NULL; + if (!getishortarg(args, 4, 2, &arg3)) + return NULL; + if (!getishortarg(args, 4, 3, &arg4)) + return NULL; + xfpt4s( arg1 , arg2 , arg3 , arg4 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void rectfi long s long s long s long s */ + +static PyObject * +gl_rectfi(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + long arg3 ; + long arg4 ; + if (!getilongarg(args, 4, 0, &arg1)) + return NULL; + if (!getilongarg(args, 4, 1, &arg2)) + return NULL; + if (!getilongarg(args, 4, 2, &arg3)) + return NULL; + if (!getilongarg(args, 4, 3, &arg4)) + return NULL; + rectfi( arg1 , arg2 , arg3 , arg4 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void recti long s long s long s long s */ + +static PyObject * +gl_recti(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + long arg3 ; + long arg4 ; + if (!getilongarg(args, 4, 0, &arg1)) + return NULL; + if (!getilongarg(args, 4, 1, &arg2)) + return NULL; + if (!getilongarg(args, 4, 2, &arg3)) + return NULL; + if (!getilongarg(args, 4, 3, &arg4)) + return NULL; + recti( arg1 , arg2 , arg3 , arg4 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void xfpt4i long s long s long s long s */ + +static PyObject * +gl_xfpt4i(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + long arg3 ; + long arg4 ; + if (!getilongarg(args, 4, 0, &arg1)) + return NULL; + if (!getilongarg(args, 4, 1, &arg2)) + return NULL; + if (!getilongarg(args, 4, 2, &arg3)) + return NULL; + if (!getilongarg(args, 4, 3, &arg4)) + return NULL; + xfpt4i( arg1 , arg2 , arg3 , arg4 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void prefposition long s long s long s long s */ + +static PyObject * +gl_prefposition(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + long arg3 ; + long arg4 ; + if (!getilongarg(args, 4, 0, &arg1)) + return NULL; + if (!getilongarg(args, 4, 1, &arg2)) + return NULL; + if (!getilongarg(args, 4, 2, &arg3)) + return NULL; + if (!getilongarg(args, 4, 3, &arg4)) + return NULL; + prefposition( arg1 , arg2 , arg3 , arg4 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void arc float s float s float s short s short s */ + +static PyObject * +gl_arc(PyObject *self, PyObject *args) +{ + float arg1 ; + float arg2 ; + float arg3 ; + short arg4 ; + short arg5 ; + if (!getifloatarg(args, 5, 0, &arg1)) + return NULL; + if (!getifloatarg(args, 5, 1, &arg2)) + return NULL; + if (!getifloatarg(args, 5, 2, &arg3)) + return NULL; + if (!getishortarg(args, 5, 3, &arg4)) + return NULL; + if (!getishortarg(args, 5, 4, &arg5)) + return NULL; + arc( arg1 , arg2 , arg3 , arg4 , arg5 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void arcf float s float s float s short s short s */ + +static PyObject * +gl_arcf(PyObject *self, PyObject *args) +{ + float arg1 ; + float arg2 ; + float arg3 ; + short arg4 ; + short arg5 ; + if (!getifloatarg(args, 5, 0, &arg1)) + return NULL; + if (!getifloatarg(args, 5, 1, &arg2)) + return NULL; + if (!getifloatarg(args, 5, 2, &arg3)) + return NULL; + if (!getishortarg(args, 5, 3, &arg4)) + return NULL; + if (!getishortarg(args, 5, 4, &arg5)) + return NULL; + arcf( arg1 , arg2 , arg3 , arg4 , arg5 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void arcfi long s long s long s short s short s */ + +static PyObject * +gl_arcfi(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + long arg3 ; + short arg4 ; + short arg5 ; + if (!getilongarg(args, 5, 0, &arg1)) + return NULL; + if (!getilongarg(args, 5, 1, &arg2)) + return NULL; + if (!getilongarg(args, 5, 2, &arg3)) + return NULL; + if (!getishortarg(args, 5, 3, &arg4)) + return NULL; + if (!getishortarg(args, 5, 4, &arg5)) + return NULL; + arcfi( arg1 , arg2 , arg3 , arg4 , arg5 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void arci long s long s long s short s short s */ + +static PyObject * +gl_arci(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + long arg3 ; + short arg4 ; + short arg5 ; + if (!getilongarg(args, 5, 0, &arg1)) + return NULL; + if (!getilongarg(args, 5, 1, &arg2)) + return NULL; + if (!getilongarg(args, 5, 2, &arg3)) + return NULL; + if (!getishortarg(args, 5, 3, &arg4)) + return NULL; + if (!getishortarg(args, 5, 4, &arg5)) + return NULL; + arci( arg1 , arg2 , arg3 , arg4 , arg5 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void bbox2 short s short s float s float s float s float s */ + +static PyObject * +gl_bbox2(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + if (!getishortarg(args, 6, 0, &arg1)) + return NULL; + if (!getishortarg(args, 6, 1, &arg2)) + return NULL; + if (!getifloatarg(args, 6, 2, &arg3)) + return NULL; + if (!getifloatarg(args, 6, 3, &arg4)) + return NULL; + if (!getifloatarg(args, 6, 4, &arg5)) + return NULL; + if (!getifloatarg(args, 6, 5, &arg6)) + return NULL; + bbox2( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void bbox2i short s short s long s long s long s long s */ + +static PyObject * +gl_bbox2i(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + long arg3 ; + long arg4 ; + long arg5 ; + long arg6 ; + if (!getishortarg(args, 6, 0, &arg1)) + return NULL; + if (!getishortarg(args, 6, 1, &arg2)) + return NULL; + if (!getilongarg(args, 6, 2, &arg3)) + return NULL; + if (!getilongarg(args, 6, 3, &arg4)) + return NULL; + if (!getilongarg(args, 6, 4, &arg5)) + return NULL; + if (!getilongarg(args, 6, 5, &arg6)) + return NULL; + bbox2i( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void bbox2s short s short s short s short s short s short s */ + +static PyObject * +gl_bbox2s(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + short arg4 ; + short arg5 ; + short arg6 ; + if (!getishortarg(args, 6, 0, &arg1)) + return NULL; + if (!getishortarg(args, 6, 1, &arg2)) + return NULL; + if (!getishortarg(args, 6, 2, &arg3)) + return NULL; + if (!getishortarg(args, 6, 3, &arg4)) + return NULL; + if (!getishortarg(args, 6, 4, &arg5)) + return NULL; + if (!getishortarg(args, 6, 5, &arg6)) + return NULL; + bbox2s( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void blink short s short s short s short s short s */ + +static PyObject * +gl_blink(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + short arg4 ; + short arg5 ; + if (!getishortarg(args, 5, 0, &arg1)) + return NULL; + if (!getishortarg(args, 5, 1, &arg2)) + return NULL; + if (!getishortarg(args, 5, 2, &arg3)) + return NULL; + if (!getishortarg(args, 5, 3, &arg4)) + return NULL; + if (!getishortarg(args, 5, 4, &arg5)) + return NULL; + blink( arg1 , arg2 , arg3 , arg4 , arg5 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void ortho float s float s float s float s float s float s */ + +static PyObject * +gl_ortho(PyObject *self, PyObject *args) +{ + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + if (!getifloatarg(args, 6, 0, &arg1)) + return NULL; + if (!getifloatarg(args, 6, 1, &arg2)) + return NULL; + if (!getifloatarg(args, 6, 2, &arg3)) + return NULL; + if (!getifloatarg(args, 6, 3, &arg4)) + return NULL; + if (!getifloatarg(args, 6, 4, &arg5)) + return NULL; + if (!getifloatarg(args, 6, 5, &arg6)) + return NULL; + ortho( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void window float s float s float s float s float s float s */ + +static PyObject * +gl_window(PyObject *self, PyObject *args) +{ + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + if (!getifloatarg(args, 6, 0, &arg1)) + return NULL; + if (!getifloatarg(args, 6, 1, &arg2)) + return NULL; + if (!getifloatarg(args, 6, 2, &arg3)) + return NULL; + if (!getifloatarg(args, 6, 3, &arg4)) + return NULL; + if (!getifloatarg(args, 6, 4, &arg5)) + return NULL; + if (!getifloatarg(args, 6, 5, &arg6)) + return NULL; + window( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void lookat float s float s float s float s float s float s short s */ + +static PyObject * +gl_lookat(PyObject *self, PyObject *args) +{ + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + short arg7 ; + if (!getifloatarg(args, 7, 0, &arg1)) + return NULL; + if (!getifloatarg(args, 7, 1, &arg2)) + return NULL; + if (!getifloatarg(args, 7, 2, &arg3)) + return NULL; + if (!getifloatarg(args, 7, 3, &arg4)) + return NULL; + if (!getifloatarg(args, 7, 4, &arg5)) + return NULL; + if (!getifloatarg(args, 7, 5, &arg6)) + return NULL; + if (!getishortarg(args, 7, 6, &arg7)) + return NULL; + lookat( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void perspective short s float s float s float s */ + +static PyObject * +gl_perspective(PyObject *self, PyObject *args) +{ + short arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + if (!getishortarg(args, 4, 0, &arg1)) + return NULL; + if (!getifloatarg(args, 4, 1, &arg2)) + return NULL; + if (!getifloatarg(args, 4, 2, &arg3)) + return NULL; + if (!getifloatarg(args, 4, 3, &arg4)) + return NULL; + perspective( arg1 , arg2 , arg3 , arg4 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void polarview float s short s short s short s */ + +static PyObject * +gl_polarview(PyObject *self, PyObject *args) +{ + float arg1 ; + short arg2 ; + short arg3 ; + short arg4 ; + if (!getifloatarg(args, 4, 0, &arg1)) + return NULL; + if (!getishortarg(args, 4, 1, &arg2)) + return NULL; + if (!getishortarg(args, 4, 2, &arg3)) + return NULL; + if (!getishortarg(args, 4, 3, &arg4)) + return NULL; + polarview( arg1 , arg2 , arg3 , arg4 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void arcfs short s short s short s short s short s */ + +static PyObject * +gl_arcfs(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + short arg4 ; + short arg5 ; + if (!getishortarg(args, 5, 0, &arg1)) + return NULL; + if (!getishortarg(args, 5, 1, &arg2)) + return NULL; + if (!getishortarg(args, 5, 2, &arg3)) + return NULL; + if (!getishortarg(args, 5, 3, &arg4)) + return NULL; + if (!getishortarg(args, 5, 4, &arg5)) + return NULL; + arcfs( arg1 , arg2 , arg3 , arg4 , arg5 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void arcs short s short s short s short s short s */ + +static PyObject * +gl_arcs(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + short arg4 ; + short arg5 ; + if (!getishortarg(args, 5, 0, &arg1)) + return NULL; + if (!getishortarg(args, 5, 1, &arg2)) + return NULL; + if (!getishortarg(args, 5, 2, &arg3)) + return NULL; + if (!getishortarg(args, 5, 3, &arg4)) + return NULL; + if (!getishortarg(args, 5, 4, &arg5)) + return NULL; + arcs( arg1 , arg2 , arg3 , arg4 , arg5 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void rectcopy short s short s short s short s short s short s */ + +static PyObject * +gl_rectcopy(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + short arg4 ; + short arg5 ; + short arg6 ; + if (!getishortarg(args, 6, 0, &arg1)) + return NULL; + if (!getishortarg(args, 6, 1, &arg2)) + return NULL; + if (!getishortarg(args, 6, 2, &arg3)) + return NULL; + if (!getishortarg(args, 6, 3, &arg4)) + return NULL; + if (!getishortarg(args, 6, 4, &arg5)) + return NULL; + if (!getishortarg(args, 6, 5, &arg6)) + return NULL; + rectcopy( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void RGBcursor short s short s short s short s short s short s short s */ + +static PyObject * +gl_RGBcursor(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + short arg4 ; + short arg5 ; + short arg6 ; + short arg7 ; + if (!getishortarg(args, 7, 0, &arg1)) + return NULL; + if (!getishortarg(args, 7, 1, &arg2)) + return NULL; + if (!getishortarg(args, 7, 2, &arg3)) + return NULL; + if (!getishortarg(args, 7, 3, &arg4)) + return NULL; + if (!getishortarg(args, 7, 4, &arg5)) + return NULL; + if (!getishortarg(args, 7, 5, &arg6)) + return NULL; + if (!getishortarg(args, 7, 6, &arg7)) + return NULL; + RGBcursor( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* long getbutton short s */ + +static PyObject * +gl_getbutton(PyObject *self, PyObject *args) +{ + long retval; + short arg1 ; + if (!getishortarg(args, 1, 0, &arg1)) + return NULL; + retval = getbutton( arg1 ); + return mknewlongobject(retval); +} + +/* long getcmmode */ + +static PyObject * +gl_getcmmode(PyObject *self, PyObject *args) +{ + long retval; + retval = getcmmode( ); + return mknewlongobject(retval); +} + +/* long getlsbackup */ + +static PyObject * +gl_getlsbackup(PyObject *self, PyObject *args) +{ + long retval; + retval = getlsbackup( ); + return mknewlongobject(retval); +} + +/* long getresetls */ + +static PyObject * +gl_getresetls(PyObject *self, PyObject *args) +{ + long retval; + retval = getresetls( ); + return mknewlongobject(retval); +} + +/* long getdcm */ + +static PyObject * +gl_getdcm(PyObject *self, PyObject *args) +{ + long retval; + retval = getdcm( ); + return mknewlongobject(retval); +} + +/* long getzbuffer */ + +static PyObject * +gl_getzbuffer(PyObject *self, PyObject *args) +{ + long retval; + retval = getzbuffer( ); + return mknewlongobject(retval); +} + +/* long ismex */ + +static PyObject * +gl_ismex(PyObject *self, PyObject *args) +{ + long retval; + retval = ismex( ); + return mknewlongobject(retval); +} + +/* long isobj long s */ + +static PyObject * +gl_isobj(PyObject *self, PyObject *args) +{ + long retval; + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + retval = isobj( arg1 ); + return mknewlongobject(retval); +} + +/* long isqueued short s */ + +static PyObject * +gl_isqueued(PyObject *self, PyObject *args) +{ + long retval; + short arg1 ; + if (!getishortarg(args, 1, 0, &arg1)) + return NULL; + retval = isqueued( arg1 ); + return mknewlongobject(retval); +} + +/* long istag long s */ + +static PyObject * +gl_istag(PyObject *self, PyObject *args) +{ + long retval; + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + retval = istag( arg1 ); + return mknewlongobject(retval); +} + +/* long genobj */ + +static PyObject * +gl_genobj(PyObject *self, PyObject *args) +{ + long retval; + retval = genobj( ); + return mknewlongobject(retval); +} + +/* long gentag */ + +static PyObject * +gl_gentag(PyObject *self, PyObject *args) +{ + long retval; + retval = gentag( ); + return mknewlongobject(retval); +} + +/* long getbuffer */ + +static PyObject * +gl_getbuffer(PyObject *self, PyObject *args) +{ + long retval; + retval = getbuffer( ); + return mknewlongobject(retval); +} + +/* long getcolor */ + +static PyObject * +gl_getcolor(PyObject *self, PyObject *args) +{ + long retval; + retval = getcolor( ); + return mknewlongobject(retval); +} + +/* long getdisplaymode */ + +static PyObject * +gl_getdisplaymode(PyObject *self, PyObject *args) +{ + long retval; + retval = getdisplaymode( ); + return mknewlongobject(retval); +} + +/* long getfont */ + +static PyObject * +gl_getfont(PyObject *self, PyObject *args) +{ + long retval; + retval = getfont( ); + return mknewlongobject(retval); +} + +/* long getheight */ + +static PyObject * +gl_getheight(PyObject *self, PyObject *args) +{ + long retval; + retval = getheight( ); + return mknewlongobject(retval); +} + +/* long gethitcode */ + +static PyObject * +gl_gethitcode(PyObject *self, PyObject *args) +{ + long retval; + retval = gethitcode( ); + return mknewlongobject(retval); +} + +/* long getlstyle */ + +static PyObject * +gl_getlstyle(PyObject *self, PyObject *args) +{ + long retval; + retval = getlstyle( ); + return mknewlongobject(retval); +} + +/* long getlwidth */ + +static PyObject * +gl_getlwidth(PyObject *self, PyObject *args) +{ + long retval; + retval = getlwidth( ); + return mknewlongobject(retval); +} + +/* long getmap */ + +static PyObject * +gl_getmap(PyObject *self, PyObject *args) +{ + long retval; + retval = getmap( ); + return mknewlongobject(retval); +} + +/* long getplanes */ + +static PyObject * +gl_getplanes(PyObject *self, PyObject *args) +{ + long retval; + retval = getplanes( ); + return mknewlongobject(retval); +} + +/* long getwritemask */ + +static PyObject * +gl_getwritemask(PyObject *self, PyObject *args) +{ + long retval; + retval = getwritemask( ); + return mknewlongobject(retval); +} + +/* long qtest */ + +static PyObject * +gl_qtest(PyObject *self, PyObject *args) +{ + long retval; + retval = qtest( ); + return mknewlongobject(retval); +} + +/* long getlsrepeat */ + +static PyObject * +gl_getlsrepeat(PyObject *self, PyObject *args) +{ + long retval; + retval = getlsrepeat( ); + return mknewlongobject(retval); +} + +/* long getmonitor */ + +static PyObject * +gl_getmonitor(PyObject *self, PyObject *args) +{ + long retval; + retval = getmonitor( ); + return mknewlongobject(retval); +} + +/* long getopenobj */ + +static PyObject * +gl_getopenobj(PyObject *self, PyObject *args) +{ + long retval; + retval = getopenobj( ); + return mknewlongobject(retval); +} + +/* long getpattern */ + +static PyObject * +gl_getpattern(PyObject *self, PyObject *args) +{ + long retval; + retval = getpattern( ); + return mknewlongobject(retval); +} + +/* long winget */ + +static PyObject * +gl_winget(PyObject *self, PyObject *args) +{ + long retval; + retval = winget( ); + return mknewlongobject(retval); +} + +/* long winattach */ + +static PyObject * +gl_winattach(PyObject *self, PyObject *args) +{ + long retval; + retval = winattach( ); + return mknewlongobject(retval); +} + +/* long getothermonitor */ + +static PyObject * +gl_getothermonitor(PyObject *self, PyObject *args) +{ + long retval; + retval = getothermonitor( ); + return mknewlongobject(retval); +} + +/* long newpup */ + +static PyObject * +gl_newpup(PyObject *self, PyObject *args) +{ + long retval; + retval = newpup( ); + return mknewlongobject(retval); +} + +/* long getvaluator short s */ + +static PyObject * +gl_getvaluator(PyObject *self, PyObject *args) +{ + long retval; + short arg1 ; + if (!getishortarg(args, 1, 0, &arg1)) + return NULL; + retval = getvaluator( arg1 ); + return mknewlongobject(retval); +} + +/* void winset long s */ + +static PyObject * +gl_winset(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + winset( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* long dopup long s */ + +static PyObject * +gl_dopup(PyObject *self, PyObject *args) +{ + long retval; + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + retval = dopup( arg1 ); + return mknewlongobject(retval); +} + +/* void getdepth short r short r */ + +static PyObject * +gl_getdepth(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + getdepth( & arg1 , & arg2 ); + { PyObject *v = PyTuple_New( 2 ); + if (v == NULL) return NULL; + PyTuple_SetItem(v, 0, mknewshortobject(arg1)); + PyTuple_SetItem(v, 1, mknewshortobject(arg2)); + return v; + } +} + +/* void getcpos short r short r */ + +static PyObject * +gl_getcpos(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + getcpos( & arg1 , & arg2 ); + { PyObject *v = PyTuple_New( 2 ); + if (v == NULL) return NULL; + PyTuple_SetItem(v, 0, mknewshortobject(arg1)); + PyTuple_SetItem(v, 1, mknewshortobject(arg2)); + return v; + } +} + +/* void getsize long r long r */ + +static PyObject * +gl_getsize(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + getsize( & arg1 , & arg2 ); + { PyObject *v = PyTuple_New( 2 ); + if (v == NULL) return NULL; + PyTuple_SetItem(v, 0, mknewlongobject(arg1)); + PyTuple_SetItem(v, 1, mknewlongobject(arg2)); + return v; + } +} + +/* void getorigin long r long r */ + +static PyObject * +gl_getorigin(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + getorigin( & arg1 , & arg2 ); + { PyObject *v = PyTuple_New( 2 ); + if (v == NULL) return NULL; + PyTuple_SetItem(v, 0, mknewlongobject(arg1)); + PyTuple_SetItem(v, 1, mknewlongobject(arg2)); + return v; + } +} + +/* void getviewport short r short r short r short r */ + +static PyObject * +gl_getviewport(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + short arg4 ; + getviewport( & arg1 , & arg2 , & arg3 , & arg4 ); + { PyObject *v = PyTuple_New( 4 ); + if (v == NULL) return NULL; + PyTuple_SetItem(v, 0, mknewshortobject(arg1)); + PyTuple_SetItem(v, 1, mknewshortobject(arg2)); + PyTuple_SetItem(v, 2, mknewshortobject(arg3)); + PyTuple_SetItem(v, 3, mknewshortobject(arg4)); + return v; + } +} + +/* void gettp short r short r short r short r */ + +static PyObject * +gl_gettp(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + short arg4 ; + gettp( & arg1 , & arg2 , & arg3 , & arg4 ); + { PyObject *v = PyTuple_New( 4 ); + if (v == NULL) return NULL; + PyTuple_SetItem(v, 0, mknewshortobject(arg1)); + PyTuple_SetItem(v, 1, mknewshortobject(arg2)); + PyTuple_SetItem(v, 2, mknewshortobject(arg3)); + PyTuple_SetItem(v, 3, mknewshortobject(arg4)); + return v; + } +} + +/* void getgpos float r float r float r float r */ + +static PyObject * +gl_getgpos(PyObject *self, PyObject *args) +{ + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + getgpos( & arg1 , & arg2 , & arg3 , & arg4 ); + { PyObject *v = PyTuple_New( 4 ); + if (v == NULL) return NULL; + PyTuple_SetItem(v, 0, mknewfloatobject(arg1)); + PyTuple_SetItem(v, 1, mknewfloatobject(arg2)); + PyTuple_SetItem(v, 2, mknewfloatobject(arg3)); + PyTuple_SetItem(v, 3, mknewfloatobject(arg4)); + return v; + } +} + +/* void winposition long s long s long s long s */ + +static PyObject * +gl_winposition(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + long arg3 ; + long arg4 ; + if (!getilongarg(args, 4, 0, &arg1)) + return NULL; + if (!getilongarg(args, 4, 1, &arg2)) + return NULL; + if (!getilongarg(args, 4, 2, &arg3)) + return NULL; + if (!getilongarg(args, 4, 3, &arg4)) + return NULL; + winposition( arg1 , arg2 , arg3 , arg4 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void gRGBcolor short r short r short r */ + +static PyObject * +gl_gRGBcolor(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + gRGBcolor( & arg1 , & arg2 , & arg3 ); + { PyObject *v = PyTuple_New( 3 ); + if (v == NULL) return NULL; + PyTuple_SetItem(v, 0, mknewshortobject(arg1)); + PyTuple_SetItem(v, 1, mknewshortobject(arg2)); + PyTuple_SetItem(v, 2, mknewshortobject(arg3)); + return v; + } +} + +/* void gRGBmask short r short r short r */ + +static PyObject * +gl_gRGBmask(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + gRGBmask( & arg1 , & arg2 , & arg3 ); + { PyObject *v = PyTuple_New( 3 ); + if (v == NULL) return NULL; + PyTuple_SetItem(v, 0, mknewshortobject(arg1)); + PyTuple_SetItem(v, 1, mknewshortobject(arg2)); + PyTuple_SetItem(v, 2, mknewshortobject(arg3)); + return v; + } +} + +/* void getscrmask short r short r short r short r */ + +static PyObject * +gl_getscrmask(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + short arg4 ; + getscrmask( & arg1 , & arg2 , & arg3 , & arg4 ); + { PyObject *v = PyTuple_New( 4 ); + if (v == NULL) return NULL; + PyTuple_SetItem(v, 0, mknewshortobject(arg1)); + PyTuple_SetItem(v, 1, mknewshortobject(arg2)); + PyTuple_SetItem(v, 2, mknewshortobject(arg3)); + PyTuple_SetItem(v, 3, mknewshortobject(arg4)); + return v; + } +} + +/* void getmcolor short s short r short r short r */ + +static PyObject * +gl_getmcolor(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + short arg4 ; + if (!getishortarg(args, 1, 0, &arg1)) + return NULL; + getmcolor( arg1 , & arg2 , & arg3 , & arg4 ); + { PyObject *v = PyTuple_New( 3 ); + if (v == NULL) return NULL; + PyTuple_SetItem(v, 0, mknewshortobject(arg2)); + PyTuple_SetItem(v, 1, mknewshortobject(arg3)); + PyTuple_SetItem(v, 2, mknewshortobject(arg4)); + return v; + } +} + +/* void mapw long s short s short s float r float r float r float r float r float r */ + +static PyObject * +gl_mapw(PyObject *self, PyObject *args) +{ + long arg1 ; + short arg2 ; + short arg3 ; + float arg4 ; + float arg5 ; + float arg6 ; + float arg7 ; + float arg8 ; + float arg9 ; + if (!getilongarg(args, 3, 0, &arg1)) + return NULL; + if (!getishortarg(args, 3, 1, &arg2)) + return NULL; + if (!getishortarg(args, 3, 2, &arg3)) + return NULL; + mapw( arg1 , arg2 , arg3 , & arg4 , & arg5 , & arg6 , & arg7 , & arg8 , & arg9 ); + { PyObject *v = PyTuple_New( 6 ); + if (v == NULL) return NULL; + PyTuple_SetItem(v, 0, mknewfloatobject(arg4)); + PyTuple_SetItem(v, 1, mknewfloatobject(arg5)); + PyTuple_SetItem(v, 2, mknewfloatobject(arg6)); + PyTuple_SetItem(v, 3, mknewfloatobject(arg7)); + PyTuple_SetItem(v, 4, mknewfloatobject(arg8)); + PyTuple_SetItem(v, 5, mknewfloatobject(arg9)); + return v; + } +} + +/* void mapw2 long s short s short s float r float r */ + +static PyObject * +gl_mapw2(PyObject *self, PyObject *args) +{ + long arg1 ; + short arg2 ; + short arg3 ; + float arg4 ; + float arg5 ; + if (!getilongarg(args, 3, 0, &arg1)) + return NULL; + if (!getishortarg(args, 3, 1, &arg2)) + return NULL; + if (!getishortarg(args, 3, 2, &arg3)) + return NULL; + mapw2( arg1 , arg2 , arg3 , & arg4 , & arg5 ); + { PyObject *v = PyTuple_New( 2 ); + if (v == NULL) return NULL; + PyTuple_SetItem(v, 0, mknewfloatobject(arg4)); + PyTuple_SetItem(v, 1, mknewfloatobject(arg5)); + return v; + } +} + +/* void getcursor short r u_short r u_short r long r */ + +static PyObject * +gl_getcursor(PyObject *self, PyObject *args) +{ + short arg1 ; + unsigned short arg2 ; + unsigned short arg3 ; + long arg4 ; + getcursor( & arg1 , & arg2 , & arg3 , & arg4 ); + { PyObject *v = PyTuple_New( 4 ); + if (v == NULL) return NULL; + PyTuple_SetItem(v, 0, mknewshortobject(arg1)); + PyTuple_SetItem(v, 1, mknewshortobject((short) arg2)); + PyTuple_SetItem(v, 2, mknewshortobject((short) arg3)); + PyTuple_SetItem(v, 3, mknewlongobject(arg4)); + return v; + } +} + +/* void cmode */ + +static PyObject * +gl_cmode(PyObject *self, PyObject *args) +{ + cmode( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void concave long s */ + +static PyObject * +gl_concave(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + concave( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void curstype long s */ + +static PyObject * +gl_curstype(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + curstype( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void drawmode long s */ + +static PyObject * +gl_drawmode(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + drawmode( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void gammaramp short s[256] short s[256] short s[256] */ + +static PyObject * +gl_gammaramp(PyObject *self, PyObject *args) +{ + short arg1 [ 256 ] ; + short arg2 [ 256 ] ; + short arg3 [ 256 ] ; + if (!getishortarray(args, 3, 0, 256 , arg1)) + return NULL; + if (!getishortarray(args, 3, 1, 256 , arg2)) + return NULL; + if (!getishortarray(args, 3, 2, 256 , arg3)) + return NULL; + gammaramp( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* long getbackface */ + +static PyObject * +gl_getbackface(PyObject *self, PyObject *args) +{ + long retval; + retval = getbackface( ); + return mknewlongobject(retval); +} + +/* long getdescender */ + +static PyObject * +gl_getdescender(PyObject *self, PyObject *args) +{ + long retval; + retval = getdescender( ); + return mknewlongobject(retval); +} + +/* long getdrawmode */ + +static PyObject * +gl_getdrawmode(PyObject *self, PyObject *args) +{ + long retval; + retval = getdrawmode( ); + return mknewlongobject(retval); +} + +/* long getmmode */ + +static PyObject * +gl_getmmode(PyObject *self, PyObject *args) +{ + long retval; + retval = getmmode( ); + return mknewlongobject(retval); +} + +/* long getsm */ + +static PyObject * +gl_getsm(PyObject *self, PyObject *args) +{ + long retval; + retval = getsm( ); + return mknewlongobject(retval); +} + +/* long getvideo long s */ + +static PyObject * +gl_getvideo(PyObject *self, PyObject *args) +{ + long retval; + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + retval = getvideo( arg1 ); + return mknewlongobject(retval); +} + +/* void imakebackground */ + +static PyObject * +gl_imakebackground(PyObject *self, PyObject *args) +{ + imakebackground( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void lmbind short s short s */ + +static PyObject * +gl_lmbind(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + if (!getishortarg(args, 2, 0, &arg1)) + return NULL; + if (!getishortarg(args, 2, 1, &arg2)) + return NULL; + lmbind( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void lmdef long s long s long s float s[arg3] */ + +static PyObject * +gl_lmdef(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + long arg3 ; + float * arg4 ; + if (!getilongarg(args, 3, 0, &arg1)) + return NULL; + if (!getilongarg(args, 3, 1, &arg2)) + return NULL; + if (!getilongarraysize(args, 3, 2, &arg3)) + return NULL; + if ((arg4 = PyMem_NEW(float , arg3 )) == NULL) + return PyErr_NoMemory(); + if (!getifloatarray(args, 3, 2, arg3 , arg4)) + return NULL; + lmdef( arg1 , arg2 , arg3 , arg4 ); + PyMem_DEL(arg4); + Py_INCREF(Py_None); + return Py_None; +} + +/* void mmode long s */ + +static PyObject * +gl_mmode(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + mmode( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void normal float s[3] */ + +static PyObject * +gl_normal(PyObject *self, PyObject *args) +{ + float arg1 [ 3 ] ; + if (!getifloatarray(args, 1, 0, 3 , arg1)) + return NULL; + normal( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void overlay long s */ + +static PyObject * +gl_overlay(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + overlay( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void RGBrange short s short s short s short s short s short s short s short s */ + +static PyObject * +gl_RGBrange(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + short arg4 ; + short arg5 ; + short arg6 ; + short arg7 ; + short arg8 ; + if (!getishortarg(args, 8, 0, &arg1)) + return NULL; + if (!getishortarg(args, 8, 1, &arg2)) + return NULL; + if (!getishortarg(args, 8, 2, &arg3)) + return NULL; + if (!getishortarg(args, 8, 3, &arg4)) + return NULL; + if (!getishortarg(args, 8, 4, &arg5)) + return NULL; + if (!getishortarg(args, 8, 5, &arg6)) + return NULL; + if (!getishortarg(args, 8, 6, &arg7)) + return NULL; + if (!getishortarg(args, 8, 7, &arg8)) + return NULL; + RGBrange( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void setvideo long s long s */ + +static PyObject * +gl_setvideo(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + if (!getilongarg(args, 2, 0, &arg1)) + return NULL; + if (!getilongarg(args, 2, 1, &arg2)) + return NULL; + setvideo( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void shademodel long s */ + +static PyObject * +gl_shademodel(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + shademodel( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void underlay long s */ + +static PyObject * +gl_underlay(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + underlay( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void bgnclosedline */ + +static PyObject * +gl_bgnclosedline(PyObject *self, PyObject *args) +{ + bgnclosedline( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void bgnline */ + +static PyObject * +gl_bgnline(PyObject *self, PyObject *args) +{ + bgnline( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void bgnpoint */ + +static PyObject * +gl_bgnpoint(PyObject *self, PyObject *args) +{ + bgnpoint( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void bgnpolygon */ + +static PyObject * +gl_bgnpolygon(PyObject *self, PyObject *args) +{ + bgnpolygon( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void bgnsurface */ + +static PyObject * +gl_bgnsurface(PyObject *self, PyObject *args) +{ + bgnsurface( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void bgntmesh */ + +static PyObject * +gl_bgntmesh(PyObject *self, PyObject *args) +{ + bgntmesh( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void bgntrim */ + +static PyObject * +gl_bgntrim(PyObject *self, PyObject *args) +{ + bgntrim( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void endclosedline */ + +static PyObject * +gl_endclosedline(PyObject *self, PyObject *args) +{ + endclosedline( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void endline */ + +static PyObject * +gl_endline(PyObject *self, PyObject *args) +{ + endline( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void endpoint */ + +static PyObject * +gl_endpoint(PyObject *self, PyObject *args) +{ + endpoint( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void endpolygon */ + +static PyObject * +gl_endpolygon(PyObject *self, PyObject *args) +{ + endpolygon( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void endsurface */ + +static PyObject * +gl_endsurface(PyObject *self, PyObject *args) +{ + endsurface( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void endtmesh */ + +static PyObject * +gl_endtmesh(PyObject *self, PyObject *args) +{ + endtmesh( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void endtrim */ + +static PyObject * +gl_endtrim(PyObject *self, PyObject *args) +{ + endtrim( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void blendfunction long s long s */ + +static PyObject * +gl_blendfunction(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + if (!getilongarg(args, 2, 0, &arg1)) + return NULL; + if (!getilongarg(args, 2, 1, &arg2)) + return NULL; + blendfunction( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void c3f float s[3] */ + +static PyObject * +gl_c3f(PyObject *self, PyObject *args) +{ + float arg1 [ 3 ] ; + if (!getifloatarray(args, 1, 0, 3 , arg1)) + return NULL; + c3f( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void c3i long s[3] */ + +static PyObject * +gl_c3i(PyObject *self, PyObject *args) +{ + long arg1 [ 3 ] ; + if (!getilongarray(args, 1, 0, 3 , arg1)) + return NULL; + c3i( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void c3s short s[3] */ + +static PyObject * +gl_c3s(PyObject *self, PyObject *args) +{ + short arg1 [ 3 ] ; + if (!getishortarray(args, 1, 0, 3 , arg1)) + return NULL; + c3s( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void c4f float s[4] */ + +static PyObject * +gl_c4f(PyObject *self, PyObject *args) +{ + float arg1 [ 4 ] ; + if (!getifloatarray(args, 1, 0, 4 , arg1)) + return NULL; + c4f( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void c4i long s[4] */ + +static PyObject * +gl_c4i(PyObject *self, PyObject *args) +{ + long arg1 [ 4 ] ; + if (!getilongarray(args, 1, 0, 4 , arg1)) + return NULL; + c4i( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void c4s short s[4] */ + +static PyObject * +gl_c4s(PyObject *self, PyObject *args) +{ + short arg1 [ 4 ] ; + if (!getishortarray(args, 1, 0, 4 , arg1)) + return NULL; + c4s( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void colorf float s */ + +static PyObject * +gl_colorf(PyObject *self, PyObject *args) +{ + float arg1 ; + if (!getifloatarg(args, 1, 0, &arg1)) + return NULL; + colorf( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void cpack long s */ + +static PyObject * +gl_cpack(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + cpack( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void czclear long s long s */ + +static PyObject * +gl_czclear(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + if (!getilongarg(args, 2, 0, &arg1)) + return NULL; + if (!getilongarg(args, 2, 1, &arg2)) + return NULL; + czclear( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void dglclose long s */ + +static PyObject * +gl_dglclose(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + dglclose( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* long dglopen char *s long s */ + +static PyObject * +gl_dglopen(PyObject *self, PyObject *args) +{ + long retval; + string arg1 ; + long arg2 ; + if (!getistringarg(args, 2, 0, &arg1)) + return NULL; + if (!getilongarg(args, 2, 1, &arg2)) + return NULL; + retval = dglopen( arg1 , arg2 ); + return mknewlongobject(retval); +} + +/* long getgdesc long s */ + +static PyObject * +gl_getgdesc(PyObject *self, PyObject *args) +{ + long retval; + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + retval = getgdesc( arg1 ); + return mknewlongobject(retval); +} + +/* void getnurbsproperty long s float r */ + +static PyObject * +gl_getnurbsproperty(PyObject *self, PyObject *args) +{ + long arg1 ; + float arg2 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + getnurbsproperty( arg1 , & arg2 ); + return mknewfloatobject(arg2); +} + +/* void glcompat long s long s */ + +static PyObject * +gl_glcompat(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + if (!getilongarg(args, 2, 0, &arg1)) + return NULL; + if (!getilongarg(args, 2, 1, &arg2)) + return NULL; + glcompat( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void iconsize long s long s */ + +static PyObject * +gl_iconsize(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + if (!getilongarg(args, 2, 0, &arg1)) + return NULL; + if (!getilongarg(args, 2, 1, &arg2)) + return NULL; + iconsize( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void icontitle char *s */ + +static PyObject * +gl_icontitle(PyObject *self, PyObject *args) +{ + string arg1 ; + if (!getistringarg(args, 1, 0, &arg1)) + return NULL; + icontitle( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void lRGBrange short s short s short s short s short s short s long s long s */ + +static PyObject * +gl_lRGBrange(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + short arg4 ; + short arg5 ; + short arg6 ; + long arg7 ; + long arg8 ; + if (!getishortarg(args, 8, 0, &arg1)) + return NULL; + if (!getishortarg(args, 8, 1, &arg2)) + return NULL; + if (!getishortarg(args, 8, 2, &arg3)) + return NULL; + if (!getishortarg(args, 8, 3, &arg4)) + return NULL; + if (!getishortarg(args, 8, 4, &arg5)) + return NULL; + if (!getishortarg(args, 8, 5, &arg6)) + return NULL; + if (!getilongarg(args, 8, 6, &arg7)) + return NULL; + if (!getilongarg(args, 8, 7, &arg8)) + return NULL; + lRGBrange( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void linesmooth long s */ + +static PyObject * +gl_linesmooth(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + linesmooth( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void lmcolor long s */ + +static PyObject * +gl_lmcolor(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + lmcolor( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void logicop long s */ + +static PyObject * +gl_logicop(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + logicop( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void lsetdepth long s long s */ + +static PyObject * +gl_lsetdepth(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + if (!getilongarg(args, 2, 0, &arg1)) + return NULL; + if (!getilongarg(args, 2, 1, &arg2)) + return NULL; + lsetdepth( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void lshaderange short s short s long s long s */ + +static PyObject * +gl_lshaderange(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + long arg3 ; + long arg4 ; + if (!getishortarg(args, 4, 0, &arg1)) + return NULL; + if (!getishortarg(args, 4, 1, &arg2)) + return NULL; + if (!getilongarg(args, 4, 2, &arg3)) + return NULL; + if (!getilongarg(args, 4, 3, &arg4)) + return NULL; + lshaderange( arg1 , arg2 , arg3 , arg4 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void n3f float s[3] */ + +static PyObject * +gl_n3f(PyObject *self, PyObject *args) +{ + float arg1 [ 3 ] ; + if (!getifloatarray(args, 1, 0, 3 , arg1)) + return NULL; + n3f( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void noborder */ + +static PyObject * +gl_noborder(PyObject *self, PyObject *args) +{ + noborder( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void pntsmooth long s */ + +static PyObject * +gl_pntsmooth(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + pntsmooth( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void readsource long s */ + +static PyObject * +gl_readsource(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + readsource( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void rectzoom float s float s */ + +static PyObject * +gl_rectzoom(PyObject *self, PyObject *args) +{ + float arg1 ; + float arg2 ; + if (!getifloatarg(args, 2, 0, &arg1)) + return NULL; + if (!getifloatarg(args, 2, 1, &arg2)) + return NULL; + rectzoom( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void sbox float s float s float s float s */ + +static PyObject * +gl_sbox(PyObject *self, PyObject *args) +{ + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + if (!getifloatarg(args, 4, 0, &arg1)) + return NULL; + if (!getifloatarg(args, 4, 1, &arg2)) + return NULL; + if (!getifloatarg(args, 4, 2, &arg3)) + return NULL; + if (!getifloatarg(args, 4, 3, &arg4)) + return NULL; + sbox( arg1 , arg2 , arg3 , arg4 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void sboxi long s long s long s long s */ + +static PyObject * +gl_sboxi(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + long arg3 ; + long arg4 ; + if (!getilongarg(args, 4, 0, &arg1)) + return NULL; + if (!getilongarg(args, 4, 1, &arg2)) + return NULL; + if (!getilongarg(args, 4, 2, &arg3)) + return NULL; + if (!getilongarg(args, 4, 3, &arg4)) + return NULL; + sboxi( arg1 , arg2 , arg3 , arg4 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void sboxs short s short s short s short s */ + +static PyObject * +gl_sboxs(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + short arg4 ; + if (!getishortarg(args, 4, 0, &arg1)) + return NULL; + if (!getishortarg(args, 4, 1, &arg2)) + return NULL; + if (!getishortarg(args, 4, 2, &arg3)) + return NULL; + if (!getishortarg(args, 4, 3, &arg4)) + return NULL; + sboxs( arg1 , arg2 , arg3 , arg4 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void sboxf float s float s float s float s */ + +static PyObject * +gl_sboxf(PyObject *self, PyObject *args) +{ + float arg1 ; + float arg2 ; + float arg3 ; + float arg4 ; + if (!getifloatarg(args, 4, 0, &arg1)) + return NULL; + if (!getifloatarg(args, 4, 1, &arg2)) + return NULL; + if (!getifloatarg(args, 4, 2, &arg3)) + return NULL; + if (!getifloatarg(args, 4, 3, &arg4)) + return NULL; + sboxf( arg1 , arg2 , arg3 , arg4 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void sboxfi long s long s long s long s */ + +static PyObject * +gl_sboxfi(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + long arg3 ; + long arg4 ; + if (!getilongarg(args, 4, 0, &arg1)) + return NULL; + if (!getilongarg(args, 4, 1, &arg2)) + return NULL; + if (!getilongarg(args, 4, 2, &arg3)) + return NULL; + if (!getilongarg(args, 4, 3, &arg4)) + return NULL; + sboxfi( arg1 , arg2 , arg3 , arg4 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void sboxfs short s short s short s short s */ + +static PyObject * +gl_sboxfs(PyObject *self, PyObject *args) +{ + short arg1 ; + short arg2 ; + short arg3 ; + short arg4 ; + if (!getishortarg(args, 4, 0, &arg1)) + return NULL; + if (!getishortarg(args, 4, 1, &arg2)) + return NULL; + if (!getishortarg(args, 4, 2, &arg3)) + return NULL; + if (!getishortarg(args, 4, 3, &arg4)) + return NULL; + sboxfs( arg1 , arg2 , arg3 , arg4 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void setnurbsproperty long s float s */ + +static PyObject * +gl_setnurbsproperty(PyObject *self, PyObject *args) +{ + long arg1 ; + float arg2 ; + if (!getilongarg(args, 2, 0, &arg1)) + return NULL; + if (!getifloatarg(args, 2, 1, &arg2)) + return NULL; + setnurbsproperty( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void setpup long s long s long s */ + +static PyObject * +gl_setpup(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + long arg3 ; + if (!getilongarg(args, 3, 0, &arg1)) + return NULL; + if (!getilongarg(args, 3, 1, &arg2)) + return NULL; + if (!getilongarg(args, 3, 2, &arg3)) + return NULL; + setpup( arg1 , arg2 , arg3 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void smoothline long s */ + +static PyObject * +gl_smoothline(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + smoothline( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void subpixel long s */ + +static PyObject * +gl_subpixel(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + subpixel( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void swaptmesh */ + +static PyObject * +gl_swaptmesh(PyObject *self, PyObject *args) +{ + swaptmesh( ); + Py_INCREF(Py_None); + return Py_None; +} + +/* long swinopen long s */ + +static PyObject * +gl_swinopen(PyObject *self, PyObject *args) +{ + long retval; + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + retval = swinopen( arg1 ); + return mknewlongobject(retval); +} + +/* void v2f float s[2] */ + +static PyObject * +gl_v2f(PyObject *self, PyObject *args) +{ + float arg1 [ 2 ] ; + if (!getifloatarray(args, 1, 0, 2 , arg1)) + return NULL; + v2f( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void v2i long s[2] */ + +static PyObject * +gl_v2i(PyObject *self, PyObject *args) +{ + long arg1 [ 2 ] ; + if (!getilongarray(args, 1, 0, 2 , arg1)) + return NULL; + v2i( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void v2s short s[2] */ + +static PyObject * +gl_v2s(PyObject *self, PyObject *args) +{ + short arg1 [ 2 ] ; + if (!getishortarray(args, 1, 0, 2 , arg1)) + return NULL; + v2s( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void v3f float s[3] */ + +static PyObject * +gl_v3f(PyObject *self, PyObject *args) +{ + float arg1 [ 3 ] ; + if (!getifloatarray(args, 1, 0, 3 , arg1)) + return NULL; + v3f( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void v3i long s[3] */ + +static PyObject * +gl_v3i(PyObject *self, PyObject *args) +{ + long arg1 [ 3 ] ; + if (!getilongarray(args, 1, 0, 3 , arg1)) + return NULL; + v3i( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void v3s short s[3] */ + +static PyObject * +gl_v3s(PyObject *self, PyObject *args) +{ + short arg1 [ 3 ] ; + if (!getishortarray(args, 1, 0, 3 , arg1)) + return NULL; + v3s( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void v4f float s[4] */ + +static PyObject * +gl_v4f(PyObject *self, PyObject *args) +{ + float arg1 [ 4 ] ; + if (!getifloatarray(args, 1, 0, 4 , arg1)) + return NULL; + v4f( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void v4i long s[4] */ + +static PyObject * +gl_v4i(PyObject *self, PyObject *args) +{ + long arg1 [ 4 ] ; + if (!getilongarray(args, 1, 0, 4 , arg1)) + return NULL; + v4i( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void v4s short s[4] */ + +static PyObject * +gl_v4s(PyObject *self, PyObject *args) +{ + short arg1 [ 4 ] ; + if (!getishortarray(args, 1, 0, 4 , arg1)) + return NULL; + v4s( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void videocmd long s */ + +static PyObject * +gl_videocmd(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + videocmd( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* long windepth long s */ + +static PyObject * +gl_windepth(PyObject *self, PyObject *args) +{ + long retval; + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + retval = windepth( arg1 ); + return mknewlongobject(retval); +} + +/* void wmpack long s */ + +static PyObject * +gl_wmpack(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + wmpack( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void zdraw long s */ + +static PyObject * +gl_zdraw(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + zdraw( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void zfunction long s */ + +static PyObject * +gl_zfunction(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + zfunction( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void zsource long s */ + +static PyObject * +gl_zsource(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + zsource( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void zwritemask long s */ + +static PyObject * +gl_zwritemask(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + zwritemask( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void v2d double s[2] */ + +static PyObject * +gl_v2d(PyObject *self, PyObject *args) +{ + double arg1 [ 2 ] ; + if (!getidoublearray(args, 1, 0, 2 , arg1)) + return NULL; + v2d( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void v3d double s[3] */ + +static PyObject * +gl_v3d(PyObject *self, PyObject *args) +{ + double arg1 [ 3 ] ; + if (!getidoublearray(args, 1, 0, 3 , arg1)) + return NULL; + v3d( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void v4d double s[4] */ + +static PyObject * +gl_v4d(PyObject *self, PyObject *args) +{ + double arg1 [ 4 ] ; + if (!getidoublearray(args, 1, 0, 4 , arg1)) + return NULL; + v4d( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* void pixmode long s long s */ + +static PyObject * +gl_pixmode(PyObject *self, PyObject *args) +{ + long arg1 ; + long arg2 ; + if (!getilongarg(args, 2, 0, &arg1)) + return NULL; + if (!getilongarg(args, 2, 1, &arg2)) + return NULL; + pixmode( arg1 , arg2 ); + Py_INCREF(Py_None); + return Py_None; +} + +/* long qgetfd */ + +static PyObject * +gl_qgetfd(PyObject *self, PyObject *args) +{ + long retval; + retval = qgetfd( ); + return mknewlongobject(retval); +} + +/* void dither long s */ + +static PyObject * +gl_dither(PyObject *self, PyObject *args) +{ + long arg1 ; + if (!getilongarg(args, 1, 0, &arg1)) + return NULL; + dither( arg1 ); + Py_INCREF(Py_None); + return Py_None; +} + +static struct PyMethodDef gl_methods[] = { + {"qread", gl_qread, METH_OLDARGS}, + {"varray", gl_varray, METH_OLDARGS}, + {"nvarray", gl_nvarray, METH_OLDARGS}, + {"vnarray", gl_vnarray, METH_OLDARGS}, + {"nurbssurface", gl_nurbssurface, METH_OLDARGS}, + {"nurbscurve", gl_nurbscurve, METH_OLDARGS}, + {"pwlcurve", gl_pwlcurve, METH_OLDARGS}, + {"pick", gl_pick, METH_OLDARGS}, + {"endpick", gl_endpick, METH_NOARGS}, + {"gselect", gl_gselect, METH_OLDARGS}, + {"endselect", gl_endselect, METH_NOARGS}, + {"getmatrix", gl_getmatrix, METH_OLDARGS}, + {"altgetmatrix", gl_altgetmatrix, METH_OLDARGS}, + {"lrectwrite", gl_lrectwrite, METH_OLDARGS}, + {"lrectread", gl_lrectread, METH_OLDARGS}, + {"readdisplay", gl_readdisplay, METH_OLDARGS}, + {"packrect", gl_packrect, METH_OLDARGS}, + {"unpackrect", gl_unpackrect, METH_OLDARGS}, + {"gversion", gl_gversion, METH_OLDARGS}, + {"clear", gl_clear, METH_OLDARGS}, + {"getshade", gl_getshade, METH_OLDARGS}, + {"devport", gl_devport, METH_OLDARGS}, + {"rdr2i", gl_rdr2i, METH_OLDARGS}, + {"rectfs", gl_rectfs, METH_OLDARGS}, + {"rects", gl_rects, METH_OLDARGS}, + {"rmv2i", gl_rmv2i, METH_OLDARGS}, + {"noport", gl_noport, METH_OLDARGS}, + {"popviewport", gl_popviewport, METH_OLDARGS}, + {"clearhitcode", gl_clearhitcode, METH_OLDARGS}, + {"closeobj", gl_closeobj, METH_OLDARGS}, + {"cursoff", gl_cursoff, METH_OLDARGS}, + {"curson", gl_curson, METH_OLDARGS}, + {"doublebuffer", gl_doublebuffer, METH_OLDARGS}, + {"finish", gl_finish, METH_OLDARGS}, + {"gconfig", gl_gconfig, METH_OLDARGS}, + {"ginit", gl_ginit, METH_OLDARGS}, + {"greset", gl_greset, METH_OLDARGS}, + {"multimap", gl_multimap, METH_OLDARGS}, + {"onemap", gl_onemap, METH_OLDARGS}, + {"popattributes", gl_popattributes, METH_OLDARGS}, + {"popmatrix", gl_popmatrix, METH_OLDARGS}, + {"pushattributes", gl_pushattributes,METH_OLDARGS}, + {"pushmatrix", gl_pushmatrix, METH_OLDARGS}, + {"pushviewport", gl_pushviewport, METH_OLDARGS}, + {"qreset", gl_qreset, METH_OLDARGS}, + {"RGBmode", gl_RGBmode, METH_OLDARGS}, + {"singlebuffer", gl_singlebuffer, METH_OLDARGS}, + {"swapbuffers", gl_swapbuffers, METH_OLDARGS}, + {"gsync", gl_gsync, METH_OLDARGS}, + {"gflush", gl_gflush, METH_OLDARGS}, + {"tpon", gl_tpon, METH_OLDARGS}, + {"tpoff", gl_tpoff, METH_OLDARGS}, + {"clkon", gl_clkon, METH_OLDARGS}, + {"clkoff", gl_clkoff, METH_OLDARGS}, + {"ringbell", gl_ringbell, METH_OLDARGS}, + {"gbegin", gl_gbegin, METH_OLDARGS}, + {"textinit", gl_textinit, METH_OLDARGS}, + {"initnames", gl_initnames, METH_OLDARGS}, + {"pclos", gl_pclos, METH_OLDARGS}, + {"popname", gl_popname, METH_OLDARGS}, + {"spclos", gl_spclos, METH_OLDARGS}, + {"zclear", gl_zclear, METH_OLDARGS}, + {"screenspace", gl_screenspace, METH_OLDARGS}, + {"reshapeviewport", gl_reshapeviewport, METH_OLDARGS}, + {"winpush", gl_winpush, METH_OLDARGS}, + {"winpop", gl_winpop, METH_OLDARGS}, + {"foreground", gl_foreground, METH_OLDARGS}, + {"endfullscrn", gl_endfullscrn, METH_OLDARGS}, + {"endpupmode", gl_endpupmode, METH_OLDARGS}, + {"fullscrn", gl_fullscrn, METH_OLDARGS}, + {"pupmode", gl_pupmode, METH_OLDARGS}, + {"winconstraints", gl_winconstraints, METH_OLDARGS}, + {"pagecolor", gl_pagecolor, METH_OLDARGS}, + {"textcolor", gl_textcolor, METH_OLDARGS}, + {"color", gl_color, METH_OLDARGS}, + {"curveit", gl_curveit, METH_OLDARGS}, + {"font", gl_font, METH_OLDARGS}, + {"linewidth", gl_linewidth, METH_OLDARGS}, + {"setlinestyle", gl_setlinestyle, METH_OLDARGS}, + {"setmap", gl_setmap, METH_OLDARGS}, + {"swapinterval", gl_swapinterval, METH_OLDARGS}, + {"writemask", gl_writemask, METH_OLDARGS}, + {"textwritemask", gl_textwritemask, METH_OLDARGS}, + {"qdevice", gl_qdevice, METH_OLDARGS}, + {"unqdevice", gl_unqdevice, METH_OLDARGS}, + {"curvebasis", gl_curvebasis, METH_OLDARGS}, + {"curveprecision", gl_curveprecision,METH_OLDARGS}, + {"loadname", gl_loadname, METH_OLDARGS}, + {"passthrough", gl_passthrough, METH_OLDARGS}, + {"pushname", gl_pushname, METH_OLDARGS}, + {"setmonitor", gl_setmonitor, METH_OLDARGS}, + {"setshade", gl_setshade, METH_OLDARGS}, + {"setpattern", gl_setpattern, METH_OLDARGS}, + {"pagewritemask", gl_pagewritemask, METH_OLDARGS}, + {"callobj", gl_callobj, METH_OLDARGS}, + {"delobj", gl_delobj, METH_OLDARGS}, + {"editobj", gl_editobj, METH_OLDARGS}, + {"makeobj", gl_makeobj, METH_OLDARGS}, + {"maketag", gl_maketag, METH_OLDARGS}, + {"chunksize", gl_chunksize, METH_OLDARGS}, + {"compactify", gl_compactify, METH_OLDARGS}, + {"deltag", gl_deltag, METH_OLDARGS}, + {"lsrepeat", gl_lsrepeat, METH_OLDARGS}, + {"objinsert", gl_objinsert, METH_OLDARGS}, + {"objreplace", gl_objreplace, METH_OLDARGS}, + {"winclose", gl_winclose, METH_OLDARGS}, + {"blanktime", gl_blanktime, METH_OLDARGS}, + {"freepup", gl_freepup, METH_OLDARGS}, + {"backbuffer", gl_backbuffer, METH_OLDARGS}, + {"frontbuffer", gl_frontbuffer, METH_OLDARGS}, + {"lsbackup", gl_lsbackup, METH_OLDARGS}, + {"resetls", gl_resetls, METH_OLDARGS}, + {"lampon", gl_lampon, METH_OLDARGS}, + {"lampoff", gl_lampoff, METH_OLDARGS}, + {"setbell", gl_setbell, METH_OLDARGS}, + {"blankscreen", gl_blankscreen, METH_OLDARGS}, + {"depthcue", gl_depthcue, METH_OLDARGS}, + {"zbuffer", gl_zbuffer, METH_OLDARGS}, + {"backface", gl_backface, METH_OLDARGS}, + {"cmov2i", gl_cmov2i, METH_OLDARGS}, + {"draw2i", gl_draw2i, METH_OLDARGS}, + {"move2i", gl_move2i, METH_OLDARGS}, + {"pnt2i", gl_pnt2i, METH_OLDARGS}, + {"patchbasis", gl_patchbasis, METH_OLDARGS}, + {"patchprecision", gl_patchprecision, METH_OLDARGS}, + {"pdr2i", gl_pdr2i, METH_OLDARGS}, + {"pmv2i", gl_pmv2i, METH_OLDARGS}, + {"rpdr2i", gl_rpdr2i, METH_OLDARGS}, + {"rpmv2i", gl_rpmv2i, METH_OLDARGS}, + {"xfpt2i", gl_xfpt2i, METH_OLDARGS}, + {"objdelete", gl_objdelete, METH_OLDARGS}, + {"patchcurves", gl_patchcurves, METH_OLDARGS}, + {"minsize", gl_minsize, METH_OLDARGS}, + {"maxsize", gl_maxsize, METH_OLDARGS}, + {"keepaspect", gl_keepaspect, METH_OLDARGS}, + {"prefsize", gl_prefsize, METH_OLDARGS}, + {"stepunit", gl_stepunit, METH_OLDARGS}, + {"fudge", gl_fudge, METH_OLDARGS}, + {"winmove", gl_winmove, METH_OLDARGS}, + {"attachcursor", gl_attachcursor, METH_OLDARGS}, + {"deflinestyle", gl_deflinestyle, METH_OLDARGS}, + {"noise", gl_noise, METH_OLDARGS}, + {"picksize", gl_picksize, METH_OLDARGS}, + {"qenter", gl_qenter, METH_OLDARGS}, + {"setdepth", gl_setdepth, METH_OLDARGS}, + {"cmov2s", gl_cmov2s, METH_OLDARGS}, + {"draw2s", gl_draw2s, METH_OLDARGS}, + {"move2s", gl_move2s, METH_OLDARGS}, + {"pdr2s", gl_pdr2s, METH_OLDARGS}, + {"pmv2s", gl_pmv2s, METH_OLDARGS}, + {"pnt2s", gl_pnt2s, METH_OLDARGS}, + {"rdr2s", gl_rdr2s, METH_OLDARGS}, + {"rmv2s", gl_rmv2s, METH_OLDARGS}, + {"rpdr2s", gl_rpdr2s, METH_OLDARGS}, + {"rpmv2s", gl_rpmv2s, METH_OLDARGS}, + {"xfpt2s", gl_xfpt2s, METH_OLDARGS}, + {"cmov2", gl_cmov2, METH_OLDARGS}, + {"draw2", gl_draw2, METH_OLDARGS}, + {"move2", gl_move2, METH_OLDARGS}, + {"pnt2", gl_pnt2, METH_OLDARGS}, + {"pdr2", gl_pdr2, METH_OLDARGS}, + {"pmv2", gl_pmv2, METH_OLDARGS}, + {"rdr2", gl_rdr2, METH_OLDARGS}, + {"rmv2", gl_rmv2, METH_OLDARGS}, + {"rpdr2", gl_rpdr2, METH_OLDARGS}, + {"rpmv2", gl_rpmv2, METH_OLDARGS}, + {"xfpt2", gl_xfpt2, METH_OLDARGS}, + {"loadmatrix", gl_loadmatrix, METH_OLDARGS}, + {"multmatrix", gl_multmatrix, METH_OLDARGS}, + {"crv", gl_crv, METH_OLDARGS}, + {"rcrv", gl_rcrv, METH_OLDARGS}, + {"addtopup", gl_addtopup, METH_OLDARGS}, + {"charstr", gl_charstr, METH_OLDARGS}, + {"getport", gl_getport, METH_OLDARGS}, + {"strwidth", gl_strwidth, METH_OLDARGS}, + {"winopen", gl_winopen, METH_OLDARGS}, + {"wintitle", gl_wintitle, METH_OLDARGS}, + {"polf", gl_polf, METH_OLDARGS}, + {"polf2", gl_polf2, METH_OLDARGS}, + {"poly", gl_poly, METH_OLDARGS}, + {"poly2", gl_poly2, METH_OLDARGS}, + {"crvn", gl_crvn, METH_OLDARGS}, + {"rcrvn", gl_rcrvn, METH_OLDARGS}, + {"polf2i", gl_polf2i, METH_OLDARGS}, + {"polfi", gl_polfi, METH_OLDARGS}, + {"poly2i", gl_poly2i, METH_OLDARGS}, + {"polyi", gl_polyi, METH_OLDARGS}, + {"polf2s", gl_polf2s, METH_OLDARGS}, + {"polfs", gl_polfs, METH_OLDARGS}, + {"polys", gl_polys, METH_OLDARGS}, + {"poly2s", gl_poly2s, METH_OLDARGS}, + {"defcursor", gl_defcursor, METH_OLDARGS}, + {"writepixels", gl_writepixels, METH_OLDARGS}, + {"defbasis", gl_defbasis, METH_OLDARGS}, + {"gewrite", gl_gewrite, METH_OLDARGS}, + {"rotate", gl_rotate, METH_OLDARGS}, + {"rot", gl_rot, METH_OLDARGS}, + {"circfi", gl_circfi, METH_OLDARGS}, + {"circi", gl_circi, METH_OLDARGS}, + {"cmovi", gl_cmovi, METH_OLDARGS}, + {"drawi", gl_drawi, METH_OLDARGS}, + {"movei", gl_movei, METH_OLDARGS}, + {"pnti", gl_pnti, METH_OLDARGS}, + {"newtag", gl_newtag, METH_OLDARGS}, + {"pdri", gl_pdri, METH_OLDARGS}, + {"pmvi", gl_pmvi, METH_OLDARGS}, + {"rdri", gl_rdri, METH_OLDARGS}, + {"rmvi", gl_rmvi, METH_OLDARGS}, + {"rpdri", gl_rpdri, METH_OLDARGS}, + {"rpmvi", gl_rpmvi, METH_OLDARGS}, + {"xfpti", gl_xfpti, METH_OLDARGS}, + {"circ", gl_circ, METH_OLDARGS}, + {"circf", gl_circf, METH_OLDARGS}, + {"cmov", gl_cmov, METH_OLDARGS}, + {"draw", gl_draw, METH_OLDARGS}, + {"move", gl_move, METH_OLDARGS}, + {"pnt", gl_pnt, METH_OLDARGS}, + {"scale", gl_scale, METH_OLDARGS}, + {"translate", gl_translate, METH_OLDARGS}, + {"pdr", gl_pdr, METH_OLDARGS}, + {"pmv", gl_pmv, METH_OLDARGS}, + {"rdr", gl_rdr, METH_OLDARGS}, + {"rmv", gl_rmv, METH_OLDARGS}, + {"rpdr", gl_rpdr, METH_OLDARGS}, + {"rpmv", gl_rpmv, METH_OLDARGS}, + {"xfpt", gl_xfpt, METH_OLDARGS}, + {"RGBcolor", gl_RGBcolor, METH_OLDARGS}, + {"RGBwritemask", gl_RGBwritemask, METH_OLDARGS}, + {"setcursor", gl_setcursor, METH_OLDARGS}, + {"tie", gl_tie, METH_OLDARGS}, + {"circfs", gl_circfs, METH_OLDARGS}, + {"circs", gl_circs, METH_OLDARGS}, + {"cmovs", gl_cmovs, METH_OLDARGS}, + {"draws", gl_draws, METH_OLDARGS}, + {"moves", gl_moves, METH_OLDARGS}, + {"pdrs", gl_pdrs, METH_OLDARGS}, + {"pmvs", gl_pmvs, METH_OLDARGS}, + {"pnts", gl_pnts, METH_OLDARGS}, + {"rdrs", gl_rdrs, METH_OLDARGS}, + {"rmvs", gl_rmvs, METH_OLDARGS}, + {"rpdrs", gl_rpdrs, METH_OLDARGS}, + {"rpmvs", gl_rpmvs, METH_OLDARGS}, + {"xfpts", gl_xfpts, METH_OLDARGS}, + {"curorigin", gl_curorigin, METH_OLDARGS}, + {"cyclemap", gl_cyclemap, METH_OLDARGS}, + {"patch", gl_patch, METH_OLDARGS}, + {"splf", gl_splf, METH_OLDARGS}, + {"splf2", gl_splf2, METH_OLDARGS}, + {"splfi", gl_splfi, METH_OLDARGS}, + {"splf2i", gl_splf2i, METH_OLDARGS}, + {"splfs", gl_splfs, METH_OLDARGS}, + {"splf2s", gl_splf2s, METH_OLDARGS}, + {"rpatch", gl_rpatch, METH_OLDARGS}, + {"ortho2", gl_ortho2, METH_OLDARGS}, + {"rect", gl_rect, METH_OLDARGS}, + {"rectf", gl_rectf, METH_OLDARGS}, + {"xfpt4", gl_xfpt4, METH_OLDARGS}, + {"textport", gl_textport, METH_OLDARGS}, + {"mapcolor", gl_mapcolor, METH_OLDARGS}, + {"scrmask", gl_scrmask, METH_OLDARGS}, + {"setvaluator", gl_setvaluator, METH_OLDARGS}, + {"viewport", gl_viewport, METH_OLDARGS}, + {"shaderange", gl_shaderange, METH_OLDARGS}, + {"xfpt4s", gl_xfpt4s, METH_OLDARGS}, + {"rectfi", gl_rectfi, METH_OLDARGS}, + {"recti", gl_recti, METH_OLDARGS}, + {"xfpt4i", gl_xfpt4i, METH_OLDARGS}, + {"prefposition", gl_prefposition, METH_OLDARGS}, + {"arc", gl_arc, METH_OLDARGS}, + {"arcf", gl_arcf, METH_OLDARGS}, + {"arcfi", gl_arcfi, METH_OLDARGS}, + {"arci", gl_arci, METH_OLDARGS}, + {"bbox2", gl_bbox2, METH_OLDARGS}, + {"bbox2i", gl_bbox2i, METH_OLDARGS}, + {"bbox2s", gl_bbox2s, METH_OLDARGS}, + {"blink", gl_blink, METH_OLDARGS}, + {"ortho", gl_ortho, METH_OLDARGS}, + {"window", gl_window, METH_OLDARGS}, + {"lookat", gl_lookat, METH_OLDARGS}, + {"perspective", gl_perspective, METH_OLDARGS}, + {"polarview", gl_polarview, METH_OLDARGS}, + {"arcfs", gl_arcfs, METH_OLDARGS}, + {"arcs", gl_arcs, METH_OLDARGS}, + {"rectcopy", gl_rectcopy, METH_OLDARGS}, + {"RGBcursor", gl_RGBcursor, METH_OLDARGS}, + {"getbutton", gl_getbutton, METH_OLDARGS}, + {"getcmmode", gl_getcmmode, METH_OLDARGS}, + {"getlsbackup", gl_getlsbackup, METH_OLDARGS}, + {"getresetls", gl_getresetls, METH_OLDARGS}, + {"getdcm", gl_getdcm, METH_OLDARGS}, + {"getzbuffer", gl_getzbuffer, METH_OLDARGS}, + {"ismex", gl_ismex, METH_OLDARGS}, + {"isobj", gl_isobj, METH_OLDARGS}, + {"isqueued", gl_isqueued, METH_OLDARGS}, + {"istag", gl_istag, METH_OLDARGS}, + {"genobj", gl_genobj, METH_OLDARGS}, + {"gentag", gl_gentag, METH_OLDARGS}, + {"getbuffer", gl_getbuffer, METH_OLDARGS}, + {"getcolor", gl_getcolor, METH_OLDARGS}, + {"getdisplaymode", gl_getdisplaymode, METH_OLDARGS}, + {"getfont", gl_getfont, METH_OLDARGS}, + {"getheight", gl_getheight, METH_OLDARGS}, + {"gethitcode", gl_gethitcode, METH_OLDARGS}, + {"getlstyle", gl_getlstyle, METH_OLDARGS}, + {"getlwidth", gl_getlwidth, METH_OLDARGS}, + {"getmap", gl_getmap, METH_OLDARGS}, + {"getplanes", gl_getplanes, METH_OLDARGS}, + {"getwritemask", gl_getwritemask, METH_OLDARGS}, + {"qtest", gl_qtest, METH_OLDARGS}, + {"getlsrepeat", gl_getlsrepeat, METH_OLDARGS}, + {"getmonitor", gl_getmonitor, METH_OLDARGS}, + {"getopenobj", gl_getopenobj, METH_OLDARGS}, + {"getpattern", gl_getpattern, METH_OLDARGS}, + {"winget", gl_winget, METH_OLDARGS}, + {"winattach", gl_winattach, METH_OLDARGS}, + {"getothermonitor", gl_getothermonitor, METH_OLDARGS}, + {"newpup", gl_newpup, METH_OLDARGS}, + {"getvaluator", gl_getvaluator, METH_OLDARGS}, + {"winset", gl_winset, METH_OLDARGS}, + {"dopup", gl_dopup, METH_OLDARGS}, + {"getdepth", gl_getdepth, METH_OLDARGS}, + {"getcpos", gl_getcpos, METH_OLDARGS}, + {"getsize", gl_getsize, METH_OLDARGS}, + {"getorigin", gl_getorigin, METH_OLDARGS}, + {"getviewport", gl_getviewport, METH_OLDARGS}, + {"gettp", gl_gettp, METH_OLDARGS}, + {"getgpos", gl_getgpos, METH_OLDARGS}, + {"winposition", gl_winposition, METH_OLDARGS}, + {"gRGBcolor", gl_gRGBcolor, METH_OLDARGS}, + {"gRGBmask", gl_gRGBmask, METH_OLDARGS}, + {"getscrmask", gl_getscrmask, METH_OLDARGS}, + {"getmcolor", gl_getmcolor, METH_OLDARGS}, + {"mapw", gl_mapw, METH_OLDARGS}, + {"mapw2", gl_mapw2, METH_OLDARGS}, + {"getcursor", gl_getcursor, METH_OLDARGS}, + {"cmode", gl_cmode, METH_OLDARGS}, + {"concave", gl_concave, METH_OLDARGS}, + {"curstype", gl_curstype, METH_OLDARGS}, + {"drawmode", gl_drawmode, METH_OLDARGS}, + {"gammaramp", gl_gammaramp, METH_OLDARGS}, + {"getbackface", gl_getbackface, METH_OLDARGS}, + {"getdescender", gl_getdescender, METH_OLDARGS}, + {"getdrawmode", gl_getdrawmode, METH_OLDARGS}, + {"getmmode", gl_getmmode, METH_OLDARGS}, + {"getsm", gl_getsm, METH_OLDARGS}, + {"getvideo", gl_getvideo, METH_OLDARGS}, + {"imakebackground", gl_imakebackground, METH_OLDARGS}, + {"lmbind", gl_lmbind, METH_OLDARGS}, + {"lmdef", gl_lmdef, METH_OLDARGS}, + {"mmode", gl_mmode, METH_OLDARGS}, + {"normal", gl_normal, METH_OLDARGS}, + {"overlay", gl_overlay, METH_OLDARGS}, + {"RGBrange", gl_RGBrange, METH_OLDARGS}, + {"setvideo", gl_setvideo, METH_OLDARGS}, + {"shademodel", gl_shademodel, METH_OLDARGS}, + {"underlay", gl_underlay, METH_OLDARGS}, + {"bgnclosedline", gl_bgnclosedline, METH_OLDARGS}, + {"bgnline", gl_bgnline, METH_OLDARGS}, + {"bgnpoint", gl_bgnpoint, METH_OLDARGS}, + {"bgnpolygon", gl_bgnpolygon, METH_OLDARGS}, + {"bgnsurface", gl_bgnsurface, METH_OLDARGS}, + {"bgntmesh", gl_bgntmesh, METH_OLDARGS}, + {"bgntrim", gl_bgntrim, METH_OLDARGS}, + {"endclosedline", gl_endclosedline, METH_OLDARGS}, + {"endline", gl_endline, METH_OLDARGS}, + {"endpoint", gl_endpoint, METH_OLDARGS}, + {"endpolygon", gl_endpolygon, METH_OLDARGS}, + {"endsurface", gl_endsurface, METH_OLDARGS}, + {"endtmesh", gl_endtmesh, METH_OLDARGS}, + {"endtrim", gl_endtrim, METH_OLDARGS}, + {"blendfunction", gl_blendfunction, METH_OLDARGS}, + {"c3f", gl_c3f, METH_OLDARGS}, + {"c3i", gl_c3i, METH_OLDARGS}, + {"c3s", gl_c3s, METH_OLDARGS}, + {"c4f", gl_c4f, METH_OLDARGS}, + {"c4i", gl_c4i, METH_OLDARGS}, + {"c4s", gl_c4s, METH_OLDARGS}, + {"colorf", gl_colorf, METH_OLDARGS}, + {"cpack", gl_cpack, METH_OLDARGS}, + {"czclear", gl_czclear, METH_OLDARGS}, + {"dglclose", gl_dglclose, METH_OLDARGS}, + {"dglopen", gl_dglopen, METH_OLDARGS}, + {"getgdesc", gl_getgdesc, METH_OLDARGS}, + {"getnurbsproperty", gl_getnurbsproperty, METH_OLDARGS}, + {"glcompat", gl_glcompat, METH_OLDARGS}, + {"iconsize", gl_iconsize, METH_OLDARGS}, + {"icontitle", gl_icontitle, METH_OLDARGS}, + {"lRGBrange", gl_lRGBrange, METH_OLDARGS}, + {"linesmooth", gl_linesmooth, METH_OLDARGS}, + {"lmcolor", gl_lmcolor, METH_OLDARGS}, + {"logicop", gl_logicop, METH_OLDARGS}, + {"lsetdepth", gl_lsetdepth, METH_OLDARGS}, + {"lshaderange", gl_lshaderange, METH_OLDARGS}, + {"n3f", gl_n3f, METH_OLDARGS}, + {"noborder", gl_noborder, METH_OLDARGS}, + {"pntsmooth", gl_pntsmooth, METH_OLDARGS}, + {"readsource", gl_readsource, METH_OLDARGS}, + {"rectzoom", gl_rectzoom, METH_OLDARGS}, + {"sbox", gl_sbox, METH_OLDARGS}, + {"sboxi", gl_sboxi, METH_OLDARGS}, + {"sboxs", gl_sboxs, METH_OLDARGS}, + {"sboxf", gl_sboxf, METH_OLDARGS}, + {"sboxfi", gl_sboxfi, METH_OLDARGS}, + {"sboxfs", gl_sboxfs, METH_OLDARGS}, + {"setnurbsproperty", gl_setnurbsproperty, METH_OLDARGS}, + {"setpup", gl_setpup, METH_OLDARGS}, + {"smoothline", gl_smoothline, METH_OLDARGS}, + {"subpixel", gl_subpixel, METH_OLDARGS}, + {"swaptmesh", gl_swaptmesh, METH_OLDARGS}, + {"swinopen", gl_swinopen, METH_OLDARGS}, + {"v2f", gl_v2f, METH_OLDARGS}, + {"v2i", gl_v2i, METH_OLDARGS}, + {"v2s", gl_v2s, METH_OLDARGS}, + {"v3f", gl_v3f, METH_OLDARGS}, + {"v3i", gl_v3i, METH_OLDARGS}, + {"v3s", gl_v3s, METH_OLDARGS}, + {"v4f", gl_v4f, METH_OLDARGS}, + {"v4i", gl_v4i, METH_OLDARGS}, + {"v4s", gl_v4s, METH_OLDARGS}, + {"videocmd", gl_videocmd, METH_OLDARGS}, + {"windepth", gl_windepth, METH_OLDARGS}, + {"wmpack", gl_wmpack, METH_OLDARGS}, + {"zdraw", gl_zdraw, METH_OLDARGS}, + {"zfunction", gl_zfunction, METH_OLDARGS}, + {"zsource", gl_zsource, METH_OLDARGS}, + {"zwritemask", gl_zwritemask, METH_OLDARGS}, + {"v2d", gl_v2d, METH_OLDARGS}, + {"v3d", gl_v3d, METH_OLDARGS}, + {"v4d", gl_v4d, METH_OLDARGS}, + {"pixmode", gl_pixmode, METH_OLDARGS}, + {"qgetfd", gl_qgetfd, METH_OLDARGS}, + {"dither", gl_dither, METH_OLDARGS}, + {NULL, NULL} /* Sentinel */ +}; + +void +initgl(void) +{ + + if (PyErr_WarnPy3k("the gl module has been removed in " + "Python 3.0", 2) < 0) + return; + + (void) Py_InitModule("gl", gl_methods); +}