--- /dev/null
+/***********************************************************
+Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
+The Netherlands.
+
+ All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the names of Stichting Mathematisch
+Centrum or CWI or Corporation for National Research Initiatives or
+CNRI not be used in advertising or publicity pertaining to
+distribution of the software without specific, written prior
+permission.
+
+While CWI is the initial source for this software, a modified version
+is made available by the Corporation for National Research Initiatives
+(CNRI) at the Internet address ftp://ftp.python.org.
+
+STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
+CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
+DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+
+******************************************************************/
+
+/*
+Input used to generate the Python module "glmodule.c".
+The stub generator is a Python script called "cgen.py".
+
+Each definition must be contained on one line:
+
+<returntype> <name> <type> <arg> <type> <arg>
+
+<returntype> can be: void, short, long (XXX maybe others?)
+
+<type> can be: char, string, short, float, long, or double
+ string indicates a null terminated string;
+ if <type> is char and <arg> begins with a *, the * is stripped
+ and <type> is changed into string
+
+<arg> has the form <mode> or <mode>[<subscript>]
+ where <mode> can be
+ s: arg is sent
+ r: arg is received (arg is a pointer)
+ and <subscript> can be (N and I are numbers):
+ N
+ argI
+ retval
+ N*argI
+ N*I
+ N*retval
+ In the case where the subscript consists of two parts
+ separated by *, the first part is the width of the matrix, and
+ the second part is the length of the matrix. This order is
+ opposite from the order used in C to declare a two-dimensional
+ matrix.
+*/
+
+/*
+ * An attempt has been made to make this module switch threads on qread
+ * calls. It is far from safe, though.
+ */
+
+#include <gl.h>
+#include <device.h>
+
+#ifdef __sgi
+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(self, args)
+ 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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ PyObject *v, *w=NULL;
+ int i, n, width;
+ double vec[3];
+ PyObject * (*getitem) Py_FPROTO((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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ return gen_nvarray(args, 0);
+}
+
+
+static PyObject *
+gl_vnarray(self, args)
+ 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(args, inorm)
+ PyObject *args;
+ int inorm;
+{
+ PyObject *v, *w, *wnorm, *wvec;
+ int i, n;
+ float norm[3], vec[3];
+ PyObject * (*getitem) Py_FPROTO((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(self, args)
+ 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(self, args)
+ 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(self, args)
+ 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(args, func)
+ 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(args, func)
+ PyObject *args;
+ long (*func)();
+{
+ PyObject *v, *w;
+ int i, nhits, n;
+ if (!PyArg_NoArgs(args))
+ return NULL;
+ 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(self, args) PyObject *self, *args; {
+ return pick_select(args, pick);
+}
+
+static PyObject *gl_endpick(self, args) PyObject *self, *args; {
+ return endpick_select(args, endpick);
+}
+
+static PyObject *gl_gselect(self, args) PyObject *self, *args; {
+ return pick_select(args, gselect);
+}
+
+static PyObject *gl_endselect(self, args) PyObject *self, *args; {
+ return endpick_select(args, 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(self, args)
+ 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(self, args)
+ 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(self, args)
+ 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(self, args)
+ 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(self, args)
+ 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(self, args)
+ 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(self, args)
+ 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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ char buf[20];
+ gversion(buf);
+ return PyString_FromString(buf);
+}
+
+
+/* End of manually written stubs */
+
+
+/* long getshade */
+
+static PyObject *
+gl_getshade(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ retval = getshade( );
+ return mknewlongobject(retval);
+}
+
+/* void devport short s long s */
+
+static PyObject *
+gl_devport(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ long arg2 ;
+ if (!PyArg_GetShort(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ if (!PyArg_GetLong(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ short arg3 ;
+ short arg4 ;
+ if (!PyArg_GetShort(args, 4, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 4, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetShort(args, 4, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ short arg3 ;
+ short arg4 ;
+ if (!PyArg_GetShort(args, 4, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 4, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetShort(args, 4, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ if (!PyArg_GetLong(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(args, 2, 1, &arg2))
+ return NULL;
+ rmv2i( arg1 , arg2 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void noport */
+
+static PyObject *
+gl_noport(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ noport( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void popviewport */
+
+static PyObject *
+gl_popviewport(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ popviewport( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void clear */
+
+static PyObject *
+gl_clear(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ clear( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void clearhitcode */
+
+static PyObject *
+gl_clearhitcode(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ clearhitcode( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void closeobj */
+
+static PyObject *
+gl_closeobj(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ closeobj( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void cursoff */
+
+static PyObject *
+gl_cursoff(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ cursoff( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void curson */
+
+static PyObject *
+gl_curson(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ curson( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void doublebuffer */
+
+static PyObject *
+gl_doublebuffer(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ doublebuffer( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void finish */
+
+static PyObject *
+gl_finish(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ finish( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void gconfig */
+
+static PyObject *
+gl_gconfig(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ gconfig( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void ginit */
+
+static PyObject *
+gl_ginit(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ ginit( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void greset */
+
+static PyObject *
+gl_greset(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ greset( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void multimap */
+
+static PyObject *
+gl_multimap(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ multimap( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void onemap */
+
+static PyObject *
+gl_onemap(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ onemap( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void popattributes */
+
+static PyObject *
+gl_popattributes(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ popattributes( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void popmatrix */
+
+static PyObject *
+gl_popmatrix(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ popmatrix( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void pushattributes */
+
+static PyObject *
+gl_pushattributes(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ pushattributes( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void pushmatrix */
+
+static PyObject *
+gl_pushmatrix(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ pushmatrix( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void pushviewport */
+
+static PyObject *
+gl_pushviewport(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ pushviewport( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void qreset */
+
+static PyObject *
+gl_qreset(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ qreset( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void RGBmode */
+
+static PyObject *
+gl_RGBmode(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ RGBmode( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void singlebuffer */
+
+static PyObject *
+gl_singlebuffer(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ singlebuffer( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void swapbuffers */
+
+static PyObject *
+gl_swapbuffers(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ swapbuffers( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void gsync */
+
+static PyObject *
+gl_gsync(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ gsync( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void gflush */
+
+static PyObject *
+gl_gflush(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ gflush( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void tpon */
+
+static PyObject *
+gl_tpon(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ tpon( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void tpoff */
+
+static PyObject *
+gl_tpoff(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ tpoff( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void clkon */
+
+static PyObject *
+gl_clkon(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ clkon( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void clkoff */
+
+static PyObject *
+gl_clkoff(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ clkoff( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void ringbell */
+
+static PyObject *
+gl_ringbell(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ ringbell( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void gbegin */
+
+static PyObject *
+gl_gbegin(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ gbegin( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void textinit */
+
+static PyObject *
+gl_textinit(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ textinit( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void initnames */
+
+static PyObject *
+gl_initnames(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ initnames( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void pclos */
+
+static PyObject *
+gl_pclos(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ pclos( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void popname */
+
+static PyObject *
+gl_popname(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ popname( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void spclos */
+
+static PyObject *
+gl_spclos(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ spclos( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void zclear */
+
+static PyObject *
+gl_zclear(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ zclear( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void screenspace */
+
+static PyObject *
+gl_screenspace(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ screenspace( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void reshapeviewport */
+
+static PyObject *
+gl_reshapeviewport(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ reshapeviewport( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void winpush */
+
+static PyObject *
+gl_winpush(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ winpush( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void winpop */
+
+static PyObject *
+gl_winpop(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ winpop( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void foreground */
+
+static PyObject *
+gl_foreground(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ foreground( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void endfullscrn */
+
+static PyObject *
+gl_endfullscrn(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ endfullscrn( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void endpupmode */
+
+static PyObject *
+gl_endpupmode(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ endpupmode( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void fullscrn */
+
+static PyObject *
+gl_fullscrn(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ fullscrn( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void pupmode */
+
+static PyObject *
+gl_pupmode(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ pupmode( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void winconstraints */
+
+static PyObject *
+gl_winconstraints(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ winconstraints( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void pagecolor short s */
+
+static PyObject *
+gl_pagecolor(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ if (!PyArg_GetShort(args, 1, 0, &arg1))
+ return NULL;
+ pagecolor( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void textcolor short s */
+
+static PyObject *
+gl_textcolor(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ if (!PyArg_GetShort(args, 1, 0, &arg1))
+ return NULL;
+ textcolor( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void color short s */
+
+static PyObject *
+gl_color(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ if (!PyArg_GetShort(args, 1, 0, &arg1))
+ return NULL;
+ color( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void curveit short s */
+
+static PyObject *
+gl_curveit(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ if (!PyArg_GetShort(args, 1, 0, &arg1))
+ return NULL;
+ curveit( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void font short s */
+
+static PyObject *
+gl_font(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ if (!PyArg_GetShort(args, 1, 0, &arg1))
+ return NULL;
+ font( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void linewidth short s */
+
+static PyObject *
+gl_linewidth(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ if (!PyArg_GetShort(args, 1, 0, &arg1))
+ return NULL;
+ linewidth( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void setlinestyle short s */
+
+static PyObject *
+gl_setlinestyle(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ if (!PyArg_GetShort(args, 1, 0, &arg1))
+ return NULL;
+ setlinestyle( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void setmap short s */
+
+static PyObject *
+gl_setmap(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ if (!PyArg_GetShort(args, 1, 0, &arg1))
+ return NULL;
+ setmap( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void swapinterval short s */
+
+static PyObject *
+gl_swapinterval(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ if (!PyArg_GetShort(args, 1, 0, &arg1))
+ return NULL;
+ swapinterval( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void writemask short s */
+
+static PyObject *
+gl_writemask(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ if (!PyArg_GetShort(args, 1, 0, &arg1))
+ return NULL;
+ writemask( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void textwritemask short s */
+
+static PyObject *
+gl_textwritemask(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ if (!PyArg_GetShort(args, 1, 0, &arg1))
+ return NULL;
+ textwritemask( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void qdevice short s */
+
+static PyObject *
+gl_qdevice(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ if (!PyArg_GetShort(args, 1, 0, &arg1))
+ return NULL;
+ qdevice( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void unqdevice short s */
+
+static PyObject *
+gl_unqdevice(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ if (!PyArg_GetShort(args, 1, 0, &arg1))
+ return NULL;
+ unqdevice( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void curvebasis short s */
+
+static PyObject *
+gl_curvebasis(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ if (!PyArg_GetShort(args, 1, 0, &arg1))
+ return NULL;
+ curvebasis( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void curveprecision short s */
+
+static PyObject *
+gl_curveprecision(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ if (!PyArg_GetShort(args, 1, 0, &arg1))
+ return NULL;
+ curveprecision( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void loadname short s */
+
+static PyObject *
+gl_loadname(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ if (!PyArg_GetShort(args, 1, 0, &arg1))
+ return NULL;
+ loadname( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void passthrough short s */
+
+static PyObject *
+gl_passthrough(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ if (!PyArg_GetShort(args, 1, 0, &arg1))
+ return NULL;
+ passthrough( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void pushname short s */
+
+static PyObject *
+gl_pushname(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ if (!PyArg_GetShort(args, 1, 0, &arg1))
+ return NULL;
+ pushname( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void setmonitor short s */
+
+static PyObject *
+gl_setmonitor(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ if (!PyArg_GetShort(args, 1, 0, &arg1))
+ return NULL;
+ setmonitor( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void setshade short s */
+
+static PyObject *
+gl_setshade(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ if (!PyArg_GetShort(args, 1, 0, &arg1))
+ return NULL;
+ setshade( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void setpattern short s */
+
+static PyObject *
+gl_setpattern(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ if (!PyArg_GetShort(args, 1, 0, &arg1))
+ return NULL;
+ setpattern( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void pagewritemask short s */
+
+static PyObject *
+gl_pagewritemask(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ if (!PyArg_GetShort(args, 1, 0, &arg1))
+ return NULL;
+ pagewritemask( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void callobj long s */
+
+static PyObject *
+gl_callobj(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ callobj( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void delobj long s */
+
+static PyObject *
+gl_delobj(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ delobj( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void editobj long s */
+
+static PyObject *
+gl_editobj(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ editobj( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void makeobj long s */
+
+static PyObject *
+gl_makeobj(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ makeobj( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void maketag long s */
+
+static PyObject *
+gl_maketag(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ maketag( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void chunksize long s */
+
+static PyObject *
+gl_chunksize(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ chunksize( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void compactify long s */
+
+static PyObject *
+gl_compactify(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ compactify( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void deltag long s */
+
+static PyObject *
+gl_deltag(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ deltag( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void lsrepeat long s */
+
+static PyObject *
+gl_lsrepeat(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ lsrepeat( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void objinsert long s */
+
+static PyObject *
+gl_objinsert(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ objinsert( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void objreplace long s */
+
+static PyObject *
+gl_objreplace(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ objreplace( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void winclose long s */
+
+static PyObject *
+gl_winclose(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ winclose( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void blanktime long s */
+
+static PyObject *
+gl_blanktime(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ blanktime( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void freepup long s */
+
+static PyObject *
+gl_freepup(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ freepup( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void backbuffer long s */
+
+static PyObject *
+gl_backbuffer(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ backbuffer( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void frontbuffer long s */
+
+static PyObject *
+gl_frontbuffer(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ frontbuffer( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void lsbackup long s */
+
+static PyObject *
+gl_lsbackup(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ lsbackup( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void resetls long s */
+
+static PyObject *
+gl_resetls(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ resetls( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void lampon long s */
+
+static PyObject *
+gl_lampon(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ lampon( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void lampoff long s */
+
+static PyObject *
+gl_lampoff(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ lampoff( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void setbell long s */
+
+static PyObject *
+gl_setbell(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ setbell( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void blankscreen long s */
+
+static PyObject *
+gl_blankscreen(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ blankscreen( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void depthcue long s */
+
+static PyObject *
+gl_depthcue(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ depthcue( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void zbuffer long s */
+
+static PyObject *
+gl_zbuffer(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ zbuffer( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void backface long s */
+
+static PyObject *
+gl_backface(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ if (!PyArg_GetLong(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ if (!PyArg_GetLong(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ if (!PyArg_GetLong(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ if (!PyArg_GetLong(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ if (!PyArg_GetLong(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ if (!PyArg_GetLong(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ if (!PyArg_GetLong(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ if (!PyArg_GetLong(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ if (!PyArg_GetLong(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ if (!PyArg_GetLong(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ if (!PyArg_GetLong(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ if (!PyArg_GetLong(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ if (!PyArg_GetLong(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ if (!PyArg_GetLong(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ if (!PyArg_GetLong(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ if (!PyArg_GetLong(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ if (!PyArg_GetLong(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ if (!PyArg_GetLong(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ if (!PyArg_GetLong(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ if (!PyArg_GetLong(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ if (!PyArg_GetShort(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ if (!PyArg_GetShort(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ if (!PyArg_GetShort(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ if (!PyArg_GetShort(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ if (!PyArg_GetShort(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ if (!PyArg_GetShort(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ if (!PyArg_GetShort(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ if (!PyArg_GetShort(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ if (!PyArg_GetShort(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ if (!PyArg_GetShort(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ if (!PyArg_GetShort(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ if (!PyArg_GetShort(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ if (!PyArg_GetShort(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ if (!PyArg_GetShort(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ if (!PyArg_GetShort(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ if (!PyArg_GetShort(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ if (!PyArg_GetShort(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 ;
+ float arg2 ;
+ if (!PyArg_GetFloat(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetFloat(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 ;
+ float arg2 ;
+ if (!PyArg_GetFloat(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetFloat(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 ;
+ float arg2 ;
+ if (!PyArg_GetFloat(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetFloat(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 ;
+ float arg2 ;
+ if (!PyArg_GetFloat(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetFloat(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 ;
+ float arg2 ;
+ if (!PyArg_GetFloat(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetFloat(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 ;
+ float arg2 ;
+ if (!PyArg_GetFloat(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetFloat(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 ;
+ float arg2 ;
+ if (!PyArg_GetFloat(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetFloat(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 ;
+ float arg2 ;
+ if (!PyArg_GetFloat(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetFloat(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 ;
+ float arg2 ;
+ if (!PyArg_GetFloat(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetFloat(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 ;
+ float arg2 ;
+ if (!PyArg_GetFloat(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetFloat(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 ;
+ float arg2 ;
+ if (!PyArg_GetFloat(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetFloat(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 [ 4 ] [ 4 ] ;
+ if (!PyArg_GetFloatArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 [ 4 ] [ 4 ] ;
+ if (!PyArg_GetFloatArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 [ 4 ] [ 3 ] ;
+ if (!PyArg_GetFloatArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 [ 4 ] [ 4 ] ;
+ if (!PyArg_GetFloatArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ string arg2 ;
+ long arg3 ;
+ if (!PyArg_GetLong(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetString(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ string arg1 ;
+ if (!PyArg_GetString(args, 1, 0, &arg1))
+ return NULL;
+ charstr( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void getport char *s */
+
+static PyObject *
+gl_getport(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ string arg1 ;
+ if (!PyArg_GetString(args, 1, 0, &arg1))
+ return NULL;
+ getport( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* long strwidth char *s */
+
+static PyObject *
+gl_strwidth(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ string arg1 ;
+ if (!PyArg_GetString(args, 1, 0, &arg1))
+ return NULL;
+ retval = strwidth( arg1 );
+ return mknewlongobject(retval);
+}
+
+/* long winopen char *s */
+
+static PyObject *
+gl_winopen(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ string arg1 ;
+ if (!PyArg_GetString(args, 1, 0, &arg1))
+ return NULL;
+ retval = winopen( arg1 );
+ return mknewlongobject(retval);
+}
+
+/* void wintitle char *s */
+
+static PyObject *
+gl_wintitle(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ string arg1 ;
+ if (!PyArg_GetString(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ float (* arg2) [ 3 ] ;
+ if (!PyArg_GetLongArraySize(args, 1, 0, &arg1))
+ return NULL;
+ arg1 = arg1 / 3;
+ if ((arg2 = (float(*)[3]) PyMem_NEW(float , 3 * arg1 )) == NULL)
+ return PyErr_NoMemory();
+ if (!PyArg_GetFloatArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ float (* arg2) [ 2 ] ;
+ if (!PyArg_GetLongArraySize(args, 1, 0, &arg1))
+ return NULL;
+ arg1 = arg1 / 2;
+ if ((arg2 = (float(*)[2]) PyMem_NEW(float , 2 * arg1 )) == NULL)
+ return PyErr_NoMemory();
+ if (!PyArg_GetFloatArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ float (* arg2) [ 3 ] ;
+ if (!PyArg_GetLongArraySize(args, 1, 0, &arg1))
+ return NULL;
+ arg1 = arg1 / 3;
+ if ((arg2 = (float(*)[3]) PyMem_NEW(float , 3 * arg1 )) == NULL)
+ return PyErr_NoMemory();
+ if (!PyArg_GetFloatArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ float (* arg2) [ 2 ] ;
+ if (!PyArg_GetLongArraySize(args, 1, 0, &arg1))
+ return NULL;
+ arg1 = arg1 / 2;
+ if ((arg2 = (float(*)[2]) PyMem_NEW(float , 2 * arg1 )) == NULL)
+ return PyErr_NoMemory();
+ if (!PyArg_GetFloatArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ float (* arg2) [ 3 ] ;
+ if (!PyArg_GetLongArraySize(args, 1, 0, &arg1))
+ return NULL;
+ arg1 = arg1 / 3;
+ if ((arg2 = (float(*)[3]) PyMem_NEW(float , 3 * arg1 )) == NULL)
+ return PyErr_NoMemory();
+ if (!PyArg_GetFloatArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ float (* arg2) [ 4 ] ;
+ if (!PyArg_GetLongArraySize(args, 1, 0, &arg1))
+ return NULL;
+ arg1 = arg1 / 4;
+ if ((arg2 = (float(*)[4]) PyMem_NEW(float , 4 * arg1 )) == NULL)
+ return PyErr_NoMemory();
+ if (!PyArg_GetFloatArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long (* arg2) [ 2 ] ;
+ if (!PyArg_GetLongArraySize(args, 1, 0, &arg1))
+ return NULL;
+ arg1 = arg1 / 2;
+ if ((arg2 = (long(*)[2]) PyMem_NEW(long , 2 * arg1 )) == NULL)
+ return PyErr_NoMemory();
+ if (!PyArg_GetLongArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long (* arg2) [ 3 ] ;
+ if (!PyArg_GetLongArraySize(args, 1, 0, &arg1))
+ return NULL;
+ arg1 = arg1 / 3;
+ if ((arg2 = (long(*)[3]) PyMem_NEW(long , 3 * arg1 )) == NULL)
+ return PyErr_NoMemory();
+ if (!PyArg_GetLongArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long (* arg2) [ 2 ] ;
+ if (!PyArg_GetLongArraySize(args, 1, 0, &arg1))
+ return NULL;
+ arg1 = arg1 / 2;
+ if ((arg2 = (long(*)[2]) PyMem_NEW(long , 2 * arg1 )) == NULL)
+ return PyErr_NoMemory();
+ if (!PyArg_GetLongArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long (* arg2) [ 3 ] ;
+ if (!PyArg_GetLongArraySize(args, 1, 0, &arg1))
+ return NULL;
+ arg1 = arg1 / 3;
+ if ((arg2 = (long(*)[3]) PyMem_NEW(long , 3 * arg1 )) == NULL)
+ return PyErr_NoMemory();
+ if (!PyArg_GetLongArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ short (* arg2) [ 2 ] ;
+ if (!PyArg_GetLongArraySize(args, 1, 0, &arg1))
+ return NULL;
+ arg1 = arg1 / 2;
+ if ((arg2 = (short(*)[2]) PyMem_NEW(short , 2 * arg1 )) == NULL)
+ return PyErr_NoMemory();
+ if (!PyArg_GetShortArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ short (* arg2) [ 3 ] ;
+ if (!PyArg_GetLongArraySize(args, 1, 0, &arg1))
+ return NULL;
+ arg1 = arg1 / 3;
+ if ((arg2 = (short(*)[3]) PyMem_NEW(short , 3 * arg1 )) == NULL)
+ return PyErr_NoMemory();
+ if (!PyArg_GetShortArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ short (* arg2) [ 3 ] ;
+ if (!PyArg_GetLongArraySize(args, 1, 0, &arg1))
+ return NULL;
+ arg1 = arg1 / 3;
+ if ((arg2 = (short(*)[3]) PyMem_NEW(short , 3 * arg1 )) == NULL)
+ return PyErr_NoMemory();
+ if (!PyArg_GetShortArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ short (* arg2) [ 2 ] ;
+ if (!PyArg_GetLongArraySize(args, 1, 0, &arg1))
+ return NULL;
+ arg1 = arg1 / 2;
+ if ((arg2 = (short(*)[2]) PyMem_NEW(short , 2 * arg1 )) == NULL)
+ return PyErr_NoMemory();
+ if (!PyArg_GetShortArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ unsigned short arg2 [ 128 ] ;
+ if (!PyArg_GetShort(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShortArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ unsigned short * arg2 ;
+ if (!PyArg_GetShortArraySize(args, 1, 0, &arg1))
+ return NULL;
+ if ((arg2 = PyMem_NEW(unsigned short , arg1 )) == NULL)
+ return PyErr_NoMemory();
+ if (!PyArg_GetShortArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ float arg2 [ 4 ] [ 4 ] ;
+ if (!PyArg_GetLong(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetFloatArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short * arg2 ;
+ if (!PyArg_GetShortArraySize(args, 1, 0, &arg1))
+ return NULL;
+ if ((arg2 = PyMem_NEW(short , arg1 )) == NULL)
+ return PyErr_NoMemory();
+ if (!PyArg_GetShortArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ char arg2 ;
+ if (!PyArg_GetShort(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetChar(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 ;
+ char arg2 ;
+ if (!PyArg_GetFloat(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetChar(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ long arg3 ;
+ if (!PyArg_GetLong(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ long arg3 ;
+ if (!PyArg_GetLong(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ long arg3 ;
+ if (!PyArg_GetLong(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ long arg3 ;
+ if (!PyArg_GetLong(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ long arg3 ;
+ if (!PyArg_GetLong(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ long arg3 ;
+ if (!PyArg_GetLong(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ long arg3 ;
+ if (!PyArg_GetLong(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ long arg3 ;
+ if (!PyArg_GetLong(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ long arg3 ;
+ if (!PyArg_GetLong(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ long arg3 ;
+ if (!PyArg_GetLong(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ long arg3 ;
+ if (!PyArg_GetLong(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ long arg3 ;
+ if (!PyArg_GetLong(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ long arg3 ;
+ if (!PyArg_GetLong(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ long arg3 ;
+ if (!PyArg_GetLong(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 ;
+ float arg2 ;
+ float arg3 ;
+ if (!PyArg_GetFloat(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetFloat(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetFloat(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 ;
+ float arg2 ;
+ float arg3 ;
+ if (!PyArg_GetFloat(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetFloat(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetFloat(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 ;
+ float arg2 ;
+ float arg3 ;
+ if (!PyArg_GetFloat(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetFloat(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetFloat(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 ;
+ float arg2 ;
+ float arg3 ;
+ if (!PyArg_GetFloat(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetFloat(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetFloat(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 ;
+ float arg2 ;
+ float arg3 ;
+ if (!PyArg_GetFloat(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetFloat(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetFloat(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 ;
+ float arg2 ;
+ float arg3 ;
+ if (!PyArg_GetFloat(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetFloat(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetFloat(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 ;
+ float arg2 ;
+ float arg3 ;
+ if (!PyArg_GetFloat(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetFloat(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetFloat(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 ;
+ float arg2 ;
+ float arg3 ;
+ if (!PyArg_GetFloat(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetFloat(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetFloat(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 ;
+ float arg2 ;
+ float arg3 ;
+ if (!PyArg_GetFloat(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetFloat(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetFloat(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 ;
+ float arg2 ;
+ float arg3 ;
+ if (!PyArg_GetFloat(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetFloat(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetFloat(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 ;
+ float arg2 ;
+ float arg3 ;
+ if (!PyArg_GetFloat(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetFloat(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetFloat(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 ;
+ float arg2 ;
+ float arg3 ;
+ if (!PyArg_GetFloat(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetFloat(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetFloat(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 ;
+ float arg2 ;
+ float arg3 ;
+ if (!PyArg_GetFloat(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetFloat(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetFloat(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 ;
+ float arg2 ;
+ float arg3 ;
+ if (!PyArg_GetFloat(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetFloat(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetFloat(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 ;
+ float arg2 ;
+ float arg3 ;
+ if (!PyArg_GetFloat(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetFloat(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetFloat(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ short arg3 ;
+ if (!PyArg_GetShort(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ short arg3 ;
+ if (!PyArg_GetShort(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ short arg3 ;
+ if (!PyArg_GetShort(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ short arg3 ;
+ if (!PyArg_GetShort(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ short arg3 ;
+ if (!PyArg_GetShort(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ short arg3 ;
+ if (!PyArg_GetShort(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ short arg3 ;
+ if (!PyArg_GetShort(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ short arg3 ;
+ if (!PyArg_GetShort(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ short arg3 ;
+ if (!PyArg_GetShort(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ short arg3 ;
+ if (!PyArg_GetShort(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ short arg3 ;
+ if (!PyArg_GetShort(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ short arg3 ;
+ if (!PyArg_GetShort(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ short arg3 ;
+ if (!PyArg_GetShort(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ short arg3 ;
+ if (!PyArg_GetShort(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ short arg3 ;
+ if (!PyArg_GetShort(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ short arg3 ;
+ if (!PyArg_GetShort(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ short arg3 ;
+ if (!PyArg_GetShort(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ short arg3 ;
+ if (!PyArg_GetShort(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ short arg3 ;
+ if (!PyArg_GetShort(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 [ 4 ] [ 4 ] ;
+ float arg2 [ 4 ] [ 4 ] ;
+ float arg3 [ 4 ] [ 4 ] ;
+ if (!PyArg_GetFloatArray(args, 3, 0, 4 * 4 , (float *) arg1))
+ return NULL;
+ if (!PyArg_GetFloatArray(args, 3, 1, 4 * 4 , (float *) arg2))
+ return NULL;
+ if (!PyArg_GetFloatArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ float (* arg2) [ 3 ] ;
+ unsigned short * arg3 ;
+ if (!PyArg_GetLongArraySize(args, 2, 0, &arg1))
+ return NULL;
+ arg1 = arg1 / 3;
+ if ((arg2 = (float(*)[3]) PyMem_NEW(float , 3 * arg1 )) == NULL)
+ return PyErr_NoMemory();
+ if (!PyArg_GetFloatArray(args, 2, 0, 3 * arg1 , (float *) arg2))
+ return NULL;
+ if ((arg3 = PyMem_NEW(unsigned short , arg1 )) == NULL)
+ return PyErr_NoMemory();
+ if (!PyArg_GetShortArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ float (* arg2) [ 2 ] ;
+ unsigned short * arg3 ;
+ if (!PyArg_GetLongArraySize(args, 2, 0, &arg1))
+ return NULL;
+ arg1 = arg1 / 2;
+ if ((arg2 = (float(*)[2]) PyMem_NEW(float , 2 * arg1 )) == NULL)
+ return PyErr_NoMemory();
+ if (!PyArg_GetFloatArray(args, 2, 0, 2 * arg1 , (float *) arg2))
+ return NULL;
+ if ((arg3 = PyMem_NEW(unsigned short , arg1 )) == NULL)
+ return PyErr_NoMemory();
+ if (!PyArg_GetShortArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long (* arg2) [ 3 ] ;
+ unsigned short * arg3 ;
+ if (!PyArg_GetLongArraySize(args, 2, 0, &arg1))
+ return NULL;
+ arg1 = arg1 / 3;
+ if ((arg2 = (long(*)[3]) PyMem_NEW(long , 3 * arg1 )) == NULL)
+ return PyErr_NoMemory();
+ if (!PyArg_GetLongArray(args, 2, 0, 3 * arg1 , (long *) arg2))
+ return NULL;
+ if ((arg3 = PyMem_NEW(unsigned short , arg1 )) == NULL)
+ return PyErr_NoMemory();
+ if (!PyArg_GetShortArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long (* arg2) [ 2 ] ;
+ unsigned short * arg3 ;
+ if (!PyArg_GetLongArraySize(args, 2, 0, &arg1))
+ return NULL;
+ arg1 = arg1 / 2;
+ if ((arg2 = (long(*)[2]) PyMem_NEW(long , 2 * arg1 )) == NULL)
+ return PyErr_NoMemory();
+ if (!PyArg_GetLongArray(args, 2, 0, 2 * arg1 , (long *) arg2))
+ return NULL;
+ if ((arg3 = PyMem_NEW(unsigned short , arg1 )) == NULL)
+ return PyErr_NoMemory();
+ if (!PyArg_GetShortArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ short (* arg2) [ 3 ] ;
+ unsigned short * arg3 ;
+ if (!PyArg_GetLongArraySize(args, 2, 0, &arg1))
+ return NULL;
+ arg1 = arg1 / 3;
+ if ((arg2 = (short(*)[3]) PyMem_NEW(short , 3 * arg1 )) == NULL)
+ return PyErr_NoMemory();
+ if (!PyArg_GetShortArray(args, 2, 0, 3 * arg1 , (short *) arg2))
+ return NULL;
+ if ((arg3 = PyMem_NEW(unsigned short , arg1 )) == NULL)
+ return PyErr_NoMemory();
+ if (!PyArg_GetShortArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ short (* arg2) [ 2 ] ;
+ unsigned short * arg3 ;
+ if (!PyArg_GetLongArraySize(args, 2, 0, &arg1))
+ return NULL;
+ arg1 = arg1 / 2;
+ if ((arg2 = (short(*)[2]) PyMem_NEW(short , 2 * arg1 )) == NULL)
+ return PyErr_NoMemory();
+ if (!PyArg_GetShortArray(args, 2, 0, 2 * arg1 , (short *) arg2))
+ return NULL;
+ if ((arg3 = PyMem_NEW(unsigned short , arg1 )) == NULL)
+ return PyErr_NoMemory();
+ if (!PyArg_GetShortArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 [ 4 ] [ 4 ] ;
+ float arg2 [ 4 ] [ 4 ] ;
+ float arg3 [ 4 ] [ 4 ] ;
+ float arg4 [ 4 ] [ 4 ] ;
+ if (!PyArg_GetFloatArray(args, 4, 0, 4 * 4 , (float *) arg1))
+ return NULL;
+ if (!PyArg_GetFloatArray(args, 4, 1, 4 * 4 , (float *) arg2))
+ return NULL;
+ if (!PyArg_GetFloatArray(args, 4, 2, 4 * 4 , (float *) arg3))
+ return NULL;
+ if (!PyArg_GetFloatArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 ;
+ float arg2 ;
+ float arg3 ;
+ float arg4 ;
+ if (!PyArg_GetFloat(args, 4, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetFloat(args, 4, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetFloat(args, 4, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetFloat(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 ;
+ float arg2 ;
+ float arg3 ;
+ float arg4 ;
+ if (!PyArg_GetFloat(args, 4, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetFloat(args, 4, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetFloat(args, 4, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetFloat(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 ;
+ float arg2 ;
+ float arg3 ;
+ float arg4 ;
+ if (!PyArg_GetFloat(args, 4, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetFloat(args, 4, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetFloat(args, 4, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetFloat(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 ;
+ float arg2 ;
+ float arg3 ;
+ float arg4 ;
+ if (!PyArg_GetFloat(args, 4, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetFloat(args, 4, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetFloat(args, 4, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetFloat(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ short arg3 ;
+ short arg4 ;
+ if (!PyArg_GetShort(args, 4, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 4, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetShort(args, 4, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ short arg3 ;
+ short arg4 ;
+ if (!PyArg_GetShort(args, 4, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 4, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetShort(args, 4, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ short arg3 ;
+ short arg4 ;
+ if (!PyArg_GetShort(args, 4, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 4, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetShort(args, 4, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ short arg3 ;
+ short arg4 ;
+ if (!PyArg_GetShort(args, 4, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 4, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetShort(args, 4, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ short arg3 ;
+ short arg4 ;
+ if (!PyArg_GetShort(args, 4, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 4, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetShort(args, 4, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ short arg3 ;
+ short arg4 ;
+ if (!PyArg_GetShort(args, 4, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 4, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetShort(args, 4, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ short arg3 ;
+ short arg4 ;
+ if (!PyArg_GetShort(args, 4, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 4, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetShort(args, 4, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ long arg3 ;
+ long arg4 ;
+ if (!PyArg_GetLong(args, 4, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(args, 4, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetLong(args, 4, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ long arg3 ;
+ long arg4 ;
+ if (!PyArg_GetLong(args, 4, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(args, 4, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetLong(args, 4, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ long arg3 ;
+ long arg4 ;
+ if (!PyArg_GetLong(args, 4, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(args, 4, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetLong(args, 4, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ long arg3 ;
+ long arg4 ;
+ if (!PyArg_GetLong(args, 4, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(args, 4, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetLong(args, 4, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 ;
+ float arg2 ;
+ float arg3 ;
+ short arg4 ;
+ short arg5 ;
+ if (!PyArg_GetFloat(args, 5, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetFloat(args, 5, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetFloat(args, 5, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetShort(args, 5, 3, &arg4))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 ;
+ float arg2 ;
+ float arg3 ;
+ short arg4 ;
+ short arg5 ;
+ if (!PyArg_GetFloat(args, 5, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetFloat(args, 5, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetFloat(args, 5, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetShort(args, 5, 3, &arg4))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ long arg3 ;
+ short arg4 ;
+ short arg5 ;
+ if (!PyArg_GetLong(args, 5, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(args, 5, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetLong(args, 5, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetShort(args, 5, 3, &arg4))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ long arg3 ;
+ short arg4 ;
+ short arg5 ;
+ if (!PyArg_GetLong(args, 5, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(args, 5, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetLong(args, 5, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetShort(args, 5, 3, &arg4))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ float arg3 ;
+ float arg4 ;
+ float arg5 ;
+ float arg6 ;
+ if (!PyArg_GetShort(args, 6, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 6, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetFloat(args, 6, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetFloat(args, 6, 3, &arg4))
+ return NULL;
+ if (!PyArg_GetFloat(args, 6, 4, &arg5))
+ return NULL;
+ if (!PyArg_GetFloat(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ long arg3 ;
+ long arg4 ;
+ long arg5 ;
+ long arg6 ;
+ if (!PyArg_GetShort(args, 6, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 6, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetLong(args, 6, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetLong(args, 6, 3, &arg4))
+ return NULL;
+ if (!PyArg_GetLong(args, 6, 4, &arg5))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ short arg3 ;
+ short arg4 ;
+ short arg5 ;
+ short arg6 ;
+ if (!PyArg_GetShort(args, 6, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 6, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetShort(args, 6, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetShort(args, 6, 3, &arg4))
+ return NULL;
+ if (!PyArg_GetShort(args, 6, 4, &arg5))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ short arg3 ;
+ short arg4 ;
+ short arg5 ;
+ if (!PyArg_GetShort(args, 5, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 5, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetShort(args, 5, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetShort(args, 5, 3, &arg4))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 ;
+ float arg2 ;
+ float arg3 ;
+ float arg4 ;
+ float arg5 ;
+ float arg6 ;
+ if (!PyArg_GetFloat(args, 6, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetFloat(args, 6, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetFloat(args, 6, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetFloat(args, 6, 3, &arg4))
+ return NULL;
+ if (!PyArg_GetFloat(args, 6, 4, &arg5))
+ return NULL;
+ if (!PyArg_GetFloat(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 ;
+ float arg2 ;
+ float arg3 ;
+ float arg4 ;
+ float arg5 ;
+ float arg6 ;
+ if (!PyArg_GetFloat(args, 6, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetFloat(args, 6, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetFloat(args, 6, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetFloat(args, 6, 3, &arg4))
+ return NULL;
+ if (!PyArg_GetFloat(args, 6, 4, &arg5))
+ return NULL;
+ if (!PyArg_GetFloat(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 ;
+ float arg2 ;
+ float arg3 ;
+ float arg4 ;
+ float arg5 ;
+ float arg6 ;
+ short arg7 ;
+ if (!PyArg_GetFloat(args, 7, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetFloat(args, 7, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetFloat(args, 7, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetFloat(args, 7, 3, &arg4))
+ return NULL;
+ if (!PyArg_GetFloat(args, 7, 4, &arg5))
+ return NULL;
+ if (!PyArg_GetFloat(args, 7, 5, &arg6))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ float arg2 ;
+ float arg3 ;
+ float arg4 ;
+ if (!PyArg_GetShort(args, 4, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetFloat(args, 4, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetFloat(args, 4, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetFloat(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 ;
+ short arg2 ;
+ short arg3 ;
+ short arg4 ;
+ if (!PyArg_GetFloat(args, 4, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 4, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetShort(args, 4, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ short arg3 ;
+ short arg4 ;
+ short arg5 ;
+ if (!PyArg_GetShort(args, 5, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 5, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetShort(args, 5, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetShort(args, 5, 3, &arg4))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ short arg3 ;
+ short arg4 ;
+ short arg5 ;
+ if (!PyArg_GetShort(args, 5, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 5, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetShort(args, 5, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetShort(args, 5, 3, &arg4))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ short arg3 ;
+ short arg4 ;
+ short arg5 ;
+ short arg6 ;
+ if (!PyArg_GetShort(args, 6, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 6, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetShort(args, 6, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetShort(args, 6, 3, &arg4))
+ return NULL;
+ if (!PyArg_GetShort(args, 6, 4, &arg5))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ short arg3 ;
+ short arg4 ;
+ short arg5 ;
+ short arg6 ;
+ short arg7 ;
+ if (!PyArg_GetShort(args, 7, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 7, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetShort(args, 7, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetShort(args, 7, 3, &arg4))
+ return NULL;
+ if (!PyArg_GetShort(args, 7, 4, &arg5))
+ return NULL;
+ if (!PyArg_GetShort(args, 7, 5, &arg6))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ short arg1 ;
+ if (!PyArg_GetShort(args, 1, 0, &arg1))
+ return NULL;
+ retval = getbutton( arg1 );
+ return mknewlongobject(retval);
+}
+
+/* long getcmmode */
+
+static PyObject *
+gl_getcmmode(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ retval = getcmmode( );
+ return mknewlongobject(retval);
+}
+
+/* long getlsbackup */
+
+static PyObject *
+gl_getlsbackup(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ retval = getlsbackup( );
+ return mknewlongobject(retval);
+}
+
+/* long getresetls */
+
+static PyObject *
+gl_getresetls(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ retval = getresetls( );
+ return mknewlongobject(retval);
+}
+
+/* long getdcm */
+
+static PyObject *
+gl_getdcm(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ retval = getdcm( );
+ return mknewlongobject(retval);
+}
+
+/* long getzbuffer */
+
+static PyObject *
+gl_getzbuffer(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ retval = getzbuffer( );
+ return mknewlongobject(retval);
+}
+
+/* long ismex */
+
+static PyObject *
+gl_ismex(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ retval = ismex( );
+ return mknewlongobject(retval);
+}
+
+/* long isobj long s */
+
+static PyObject *
+gl_isobj(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ retval = isobj( arg1 );
+ return mknewlongobject(retval);
+}
+
+/* long isqueued short s */
+
+static PyObject *
+gl_isqueued(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ short arg1 ;
+ if (!PyArg_GetShort(args, 1, 0, &arg1))
+ return NULL;
+ retval = isqueued( arg1 );
+ return mknewlongobject(retval);
+}
+
+/* long istag long s */
+
+static PyObject *
+gl_istag(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ retval = istag( arg1 );
+ return mknewlongobject(retval);
+}
+
+/* long genobj */
+
+static PyObject *
+gl_genobj(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ retval = genobj( );
+ return mknewlongobject(retval);
+}
+
+/* long gentag */
+
+static PyObject *
+gl_gentag(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ retval = gentag( );
+ return mknewlongobject(retval);
+}
+
+/* long getbuffer */
+
+static PyObject *
+gl_getbuffer(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ retval = getbuffer( );
+ return mknewlongobject(retval);
+}
+
+/* long getcolor */
+
+static PyObject *
+gl_getcolor(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ retval = getcolor( );
+ return mknewlongobject(retval);
+}
+
+/* long getdisplaymode */
+
+static PyObject *
+gl_getdisplaymode(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ retval = getdisplaymode( );
+ return mknewlongobject(retval);
+}
+
+/* long getfont */
+
+static PyObject *
+gl_getfont(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ retval = getfont( );
+ return mknewlongobject(retval);
+}
+
+/* long getheight */
+
+static PyObject *
+gl_getheight(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ retval = getheight( );
+ return mknewlongobject(retval);
+}
+
+/* long gethitcode */
+
+static PyObject *
+gl_gethitcode(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ retval = gethitcode( );
+ return mknewlongobject(retval);
+}
+
+/* long getlstyle */
+
+static PyObject *
+gl_getlstyle(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ retval = getlstyle( );
+ return mknewlongobject(retval);
+}
+
+/* long getlwidth */
+
+static PyObject *
+gl_getlwidth(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ retval = getlwidth( );
+ return mknewlongobject(retval);
+}
+
+/* long getmap */
+
+static PyObject *
+gl_getmap(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ retval = getmap( );
+ return mknewlongobject(retval);
+}
+
+/* long getplanes */
+
+static PyObject *
+gl_getplanes(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ retval = getplanes( );
+ return mknewlongobject(retval);
+}
+
+/* long getwritemask */
+
+static PyObject *
+gl_getwritemask(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ retval = getwritemask( );
+ return mknewlongobject(retval);
+}
+
+/* long qtest */
+
+static PyObject *
+gl_qtest(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ retval = qtest( );
+ return mknewlongobject(retval);
+}
+
+/* long getlsrepeat */
+
+static PyObject *
+gl_getlsrepeat(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ retval = getlsrepeat( );
+ return mknewlongobject(retval);
+}
+
+/* long getmonitor */
+
+static PyObject *
+gl_getmonitor(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ retval = getmonitor( );
+ return mknewlongobject(retval);
+}
+
+/* long getopenobj */
+
+static PyObject *
+gl_getopenobj(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ retval = getopenobj( );
+ return mknewlongobject(retval);
+}
+
+/* long getpattern */
+
+static PyObject *
+gl_getpattern(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ retval = getpattern( );
+ return mknewlongobject(retval);
+}
+
+/* long winget */
+
+static PyObject *
+gl_winget(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ retval = winget( );
+ return mknewlongobject(retval);
+}
+
+/* long winattach */
+
+static PyObject *
+gl_winattach(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ retval = winattach( );
+ return mknewlongobject(retval);
+}
+
+/* long getothermonitor */
+
+static PyObject *
+gl_getothermonitor(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ retval = getothermonitor( );
+ return mknewlongobject(retval);
+}
+
+/* long newpup */
+
+static PyObject *
+gl_newpup(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ retval = newpup( );
+ return mknewlongobject(retval);
+}
+
+/* long getvaluator short s */
+
+static PyObject *
+gl_getvaluator(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ short arg1 ;
+ if (!PyArg_GetShort(args, 1, 0, &arg1))
+ return NULL;
+ retval = getvaluator( arg1 );
+ return mknewlongobject(retval);
+}
+
+/* void winset long s */
+
+static PyObject *
+gl_winset(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ winset( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* long dopup long s */
+
+static PyObject *
+gl_dopup(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ retval = dopup( arg1 );
+ return mknewlongobject(retval);
+}
+
+/* void getdepth short r short r */
+
+static PyObject *
+gl_getdepth(self, args)
+ 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(self, args)
+ 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(self, args)
+ 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(self, args)
+ 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(self, args)
+ 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(self, args)
+ 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(self, args)
+ 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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ long arg3 ;
+ long arg4 ;
+ if (!PyArg_GetLong(args, 4, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(args, 4, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetLong(args, 4, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ 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(self, args)
+ 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(self, args)
+ 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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ short arg3 ;
+ short arg4 ;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ short arg2 ;
+ short arg3 ;
+ float arg4 ;
+ float arg5 ;
+ float arg6 ;
+ float arg7 ;
+ float arg8 ;
+ float arg9 ;
+ if (!PyArg_GetLong(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ short arg2 ;
+ short arg3 ;
+ float arg4 ;
+ float arg5 ;
+ if (!PyArg_GetLong(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ 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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ cmode( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void concave long s */
+
+static PyObject *
+gl_concave(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ concave( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void curstype long s */
+
+static PyObject *
+gl_curstype(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ curstype( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void drawmode long s */
+
+static PyObject *
+gl_drawmode(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 [ 256 ] ;
+ short arg2 [ 256 ] ;
+ short arg3 [ 256 ] ;
+ if (!PyArg_GetShortArray(args, 3, 0, 256 , arg1))
+ return NULL;
+ if (!PyArg_GetShortArray(args, 3, 1, 256 , arg2))
+ return NULL;
+ if (!PyArg_GetShortArray(args, 3, 2, 256 , arg3))
+ return NULL;
+ gammaramp( arg1 , arg2 , arg3 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* long getbackface */
+
+static PyObject *
+gl_getbackface(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ retval = getbackface( );
+ return mknewlongobject(retval);
+}
+
+/* long getdescender */
+
+static PyObject *
+gl_getdescender(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ retval = getdescender( );
+ return mknewlongobject(retval);
+}
+
+/* long getdrawmode */
+
+static PyObject *
+gl_getdrawmode(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ retval = getdrawmode( );
+ return mknewlongobject(retval);
+}
+
+/* long getmmode */
+
+static PyObject *
+gl_getmmode(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ retval = getmmode( );
+ return mknewlongobject(retval);
+}
+
+/* long getsm */
+
+static PyObject *
+gl_getsm(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ retval = getsm( );
+ return mknewlongobject(retval);
+}
+
+/* long getvideo long s */
+
+static PyObject *
+gl_getvideo(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ retval = getvideo( arg1 );
+ return mknewlongobject(retval);
+}
+
+/* void imakebackground */
+
+static PyObject *
+gl_imakebackground(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ imakebackground( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void lmbind short s short s */
+
+static PyObject *
+gl_lmbind(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ if (!PyArg_GetShort(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ long arg3 ;
+ float * arg4 ;
+ if (!PyArg_GetLong(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetLongArraySize(args, 3, 2, &arg3))
+ return NULL;
+ if ((arg4 = PyMem_NEW(float , arg3 )) == NULL)
+ return PyErr_NoMemory();
+ if (!PyArg_GetFloatArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ mmode( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void normal float s[3] */
+
+static PyObject *
+gl_normal(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 [ 3 ] ;
+ if (!PyArg_GetFloatArray(args, 1, 0, 3 , arg1))
+ return NULL;
+ normal( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void overlay long s */
+
+static PyObject *
+gl_overlay(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ short arg3 ;
+ short arg4 ;
+ short arg5 ;
+ short arg6 ;
+ short arg7 ;
+ short arg8 ;
+ if (!PyArg_GetShort(args, 8, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 8, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetShort(args, 8, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetShort(args, 8, 3, &arg4))
+ return NULL;
+ if (!PyArg_GetShort(args, 8, 4, &arg5))
+ return NULL;
+ if (!PyArg_GetShort(args, 8, 5, &arg6))
+ return NULL;
+ if (!PyArg_GetShort(args, 8, 6, &arg7))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ if (!PyArg_GetLong(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(args, 2, 1, &arg2))
+ return NULL;
+ setvideo( arg1 , arg2 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void shademodel long s */
+
+static PyObject *
+gl_shademodel(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ shademodel( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void underlay long s */
+
+static PyObject *
+gl_underlay(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ underlay( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void bgnclosedline */
+
+static PyObject *
+gl_bgnclosedline(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ bgnclosedline( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void bgnline */
+
+static PyObject *
+gl_bgnline(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ bgnline( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void bgnpoint */
+
+static PyObject *
+gl_bgnpoint(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ bgnpoint( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void bgnpolygon */
+
+static PyObject *
+gl_bgnpolygon(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ bgnpolygon( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void bgnsurface */
+
+static PyObject *
+gl_bgnsurface(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ bgnsurface( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void bgntmesh */
+
+static PyObject *
+gl_bgntmesh(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ bgntmesh( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void bgntrim */
+
+static PyObject *
+gl_bgntrim(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ bgntrim( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void endclosedline */
+
+static PyObject *
+gl_endclosedline(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ endclosedline( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void endline */
+
+static PyObject *
+gl_endline(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ endline( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void endpoint */
+
+static PyObject *
+gl_endpoint(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ endpoint( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void endpolygon */
+
+static PyObject *
+gl_endpolygon(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ endpolygon( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void endsurface */
+
+static PyObject *
+gl_endsurface(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ endsurface( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void endtmesh */
+
+static PyObject *
+gl_endtmesh(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ endtmesh( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void endtrim */
+
+static PyObject *
+gl_endtrim(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ endtrim( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void blendfunction long s long s */
+
+static PyObject *
+gl_blendfunction(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ if (!PyArg_GetLong(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 [ 3 ] ;
+ if (!PyArg_GetFloatArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 [ 3 ] ;
+ if (!PyArg_GetLongArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 [ 3 ] ;
+ if (!PyArg_GetShortArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 [ 4 ] ;
+ if (!PyArg_GetFloatArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 [ 4 ] ;
+ if (!PyArg_GetLongArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 [ 4 ] ;
+ if (!PyArg_GetShortArray(args, 1, 0, 4 , arg1))
+ return NULL;
+ c4s( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void colorf float s */
+
+static PyObject *
+gl_colorf(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 ;
+ if (!PyArg_GetFloat(args, 1, 0, &arg1))
+ return NULL;
+ colorf( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void cpack long s */
+
+static PyObject *
+gl_cpack(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ if (!PyArg_GetLong(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(args, 2, 1, &arg2))
+ return NULL;
+ czclear( arg1 , arg2 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void dglclose long s */
+
+static PyObject *
+gl_dglclose(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ string arg1 ;
+ long arg2 ;
+ if (!PyArg_GetString(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(args, 2, 1, &arg2))
+ return NULL;
+ retval = dglopen( arg1 , arg2 );
+ return mknewlongobject(retval);
+}
+
+/* long getgdesc long s */
+
+static PyObject *
+gl_getgdesc(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ retval = getgdesc( arg1 );
+ return mknewlongobject(retval);
+}
+
+/* void getnurbsproperty long s float r */
+
+static PyObject *
+gl_getnurbsproperty(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ float arg2 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ getnurbsproperty( arg1 , & arg2 );
+ return mknewfloatobject(arg2);
+}
+
+/* void glcompat long s long s */
+
+static PyObject *
+gl_glcompat(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ if (!PyArg_GetLong(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ if (!PyArg_GetLong(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(args, 2, 1, &arg2))
+ return NULL;
+ iconsize( arg1 , arg2 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void icontitle char *s */
+
+static PyObject *
+gl_icontitle(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ string arg1 ;
+ if (!PyArg_GetString(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ short arg3 ;
+ short arg4 ;
+ short arg5 ;
+ short arg6 ;
+ long arg7 ;
+ long arg8 ;
+ if (!PyArg_GetShort(args, 8, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 8, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetShort(args, 8, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetShort(args, 8, 3, &arg4))
+ return NULL;
+ if (!PyArg_GetShort(args, 8, 4, &arg5))
+ return NULL;
+ if (!PyArg_GetShort(args, 8, 5, &arg6))
+ return NULL;
+ if (!PyArg_GetLong(args, 8, 6, &arg7))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ linesmooth( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void lmcolor long s */
+
+static PyObject *
+gl_lmcolor(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ lmcolor( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void logicop long s */
+
+static PyObject *
+gl_logicop(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ if (!PyArg_GetLong(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ long arg3 ;
+ long arg4 ;
+ if (!PyArg_GetShort(args, 4, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 4, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetLong(args, 4, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 [ 3 ] ;
+ if (!PyArg_GetFloatArray(args, 1, 0, 3 , arg1))
+ return NULL;
+ n3f( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void noborder */
+
+static PyObject *
+gl_noborder(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ noborder( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void pntsmooth long s */
+
+static PyObject *
+gl_pntsmooth(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ pntsmooth( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void readsource long s */
+
+static PyObject *
+gl_readsource(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 ;
+ float arg2 ;
+ if (!PyArg_GetFloat(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetFloat(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 ;
+ float arg2 ;
+ float arg3 ;
+ float arg4 ;
+ if (!PyArg_GetFloat(args, 4, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetFloat(args, 4, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetFloat(args, 4, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetFloat(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ long arg3 ;
+ long arg4 ;
+ if (!PyArg_GetLong(args, 4, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(args, 4, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetLong(args, 4, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ short arg3 ;
+ short arg4 ;
+ if (!PyArg_GetShort(args, 4, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 4, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetShort(args, 4, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 ;
+ float arg2 ;
+ float arg3 ;
+ float arg4 ;
+ if (!PyArg_GetFloat(args, 4, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetFloat(args, 4, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetFloat(args, 4, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetFloat(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ long arg3 ;
+ long arg4 ;
+ if (!PyArg_GetLong(args, 4, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(args, 4, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetLong(args, 4, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 ;
+ short arg2 ;
+ short arg3 ;
+ short arg4 ;
+ if (!PyArg_GetShort(args, 4, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetShort(args, 4, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetShort(args, 4, 2, &arg3))
+ return NULL;
+ if (!PyArg_GetShort(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ float arg2 ;
+ if (!PyArg_GetLong(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetFloat(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ long arg3 ;
+ if (!PyArg_GetLong(args, 3, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(args, 3, 1, &arg2))
+ return NULL;
+ if (!PyArg_GetLong(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ smoothline( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void subpixel long s */
+
+static PyObject *
+gl_subpixel(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ subpixel( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void swaptmesh */
+
+static PyObject *
+gl_swaptmesh(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ swaptmesh( );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* long swinopen long s */
+
+static PyObject *
+gl_swinopen(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ retval = swinopen( arg1 );
+ return mknewlongobject(retval);
+}
+
+/* void v2f float s[2] */
+
+static PyObject *
+gl_v2f(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 [ 2 ] ;
+ if (!PyArg_GetFloatArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 [ 2 ] ;
+ if (!PyArg_GetLongArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 [ 2 ] ;
+ if (!PyArg_GetShortArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 [ 3 ] ;
+ if (!PyArg_GetFloatArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 [ 3 ] ;
+ if (!PyArg_GetLongArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 [ 3 ] ;
+ if (!PyArg_GetShortArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ float arg1 [ 4 ] ;
+ if (!PyArg_GetFloatArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 [ 4 ] ;
+ if (!PyArg_GetLongArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ short arg1 [ 4 ] ;
+ if (!PyArg_GetShortArray(args, 1, 0, 4 , arg1))
+ return NULL;
+ v4s( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void videocmd long s */
+
+static PyObject *
+gl_videocmd(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ videocmd( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* long windepth long s */
+
+static PyObject *
+gl_windepth(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ retval = windepth( arg1 );
+ return mknewlongobject(retval);
+}
+
+/* void wmpack long s */
+
+static PyObject *
+gl_wmpack(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ wmpack( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void zdraw long s */
+
+static PyObject *
+gl_zdraw(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ zdraw( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void zfunction long s */
+
+static PyObject *
+gl_zfunction(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ zfunction( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void zsource long s */
+
+static PyObject *
+gl_zsource(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ zsource( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void zwritemask long s */
+
+static PyObject *
+gl_zwritemask(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ zwritemask( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* void v2d double s[2] */
+
+static PyObject *
+gl_v2d(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ double arg1 [ 2 ] ;
+ if (!PyArg_GetDoubleArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ double arg1 [ 3 ] ;
+ if (!PyArg_GetDoubleArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ double arg1 [ 4 ] ;
+ if (!PyArg_GetDoubleArray(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(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ long arg2 ;
+ if (!PyArg_GetLong(args, 2, 0, &arg1))
+ return NULL;
+ if (!PyArg_GetLong(args, 2, 1, &arg2))
+ return NULL;
+ pixmode( arg1 , arg2 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+/* long qgetfd */
+
+static PyObject *
+gl_qgetfd(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long retval;
+ retval = qgetfd( );
+ return mknewlongobject(retval);
+}
+
+/* void dither long s */
+
+static PyObject *
+gl_dither(self, args)
+ PyObject *self;
+ PyObject *args;
+{
+ long arg1 ;
+ if (!PyArg_GetLong(args, 1, 0, &arg1))
+ return NULL;
+ dither( arg1 );
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+static PyMethodDef gl_methods[] = {
+ {"qread", gl_qread},
+ {"varray", gl_varray},
+ {"nvarray", gl_nvarray},
+ {"vnarray", gl_vnarray},
+ {"nurbssurface", gl_nurbssurface},
+ {"nurbscurve", gl_nurbscurve},
+ {"pwlcurve", gl_pwlcurve},
+ {"pick", gl_pick},
+ {"endpick", gl_endpick},
+ {"gselect", gl_gselect},
+ {"endselect", gl_endselect},
+ {"getmatrix", gl_getmatrix},
+ {"altgetmatrix", gl_altgetmatrix},
+ {"lrectwrite", gl_lrectwrite},
+ {"lrectread", gl_lrectread},
+ {"readdisplay", gl_readdisplay},
+ {"packrect", gl_packrect},
+ {"unpackrect", gl_unpackrect},
+ {"gversion", gl_gversion},
+ {"getshade", gl_getshade},
+ {"devport", gl_devport},
+ {"rdr2i", gl_rdr2i},
+ {"rectfs", gl_rectfs},
+ {"rects", gl_rects},
+ {"rmv2i", gl_rmv2i},
+ {"noport", gl_noport},
+ {"popviewport", gl_popviewport},
+ {"clear", gl_clear},
+ {"clearhitcode", gl_clearhitcode},
+ {"closeobj", gl_closeobj},
+ {"cursoff", gl_cursoff},
+ {"curson", gl_curson},
+ {"doublebuffer", gl_doublebuffer},
+ {"finish", gl_finish},
+ {"gconfig", gl_gconfig},
+ {"ginit", gl_ginit},
+ {"greset", gl_greset},
+ {"multimap", gl_multimap},
+ {"onemap", gl_onemap},
+ {"popattributes", gl_popattributes},
+ {"popmatrix", gl_popmatrix},
+ {"pushattributes", gl_pushattributes},
+ {"pushmatrix", gl_pushmatrix},
+ {"pushviewport", gl_pushviewport},
+ {"qreset", gl_qreset},
+ {"RGBmode", gl_RGBmode},
+ {"singlebuffer", gl_singlebuffer},
+ {"swapbuffers", gl_swapbuffers},
+ {"gsync", gl_gsync},
+ {"gflush", gl_gflush},
+ {"tpon", gl_tpon},
+ {"tpoff", gl_tpoff},
+ {"clkon", gl_clkon},
+ {"clkoff", gl_clkoff},
+ {"ringbell", gl_ringbell},
+ {"gbegin", gl_gbegin},
+ {"textinit", gl_textinit},
+ {"initnames", gl_initnames},
+ {"pclos", gl_pclos},
+ {"popname", gl_popname},
+ {"spclos", gl_spclos},
+ {"zclear", gl_zclear},
+ {"screenspace", gl_screenspace},
+ {"reshapeviewport", gl_reshapeviewport},
+ {"winpush", gl_winpush},
+ {"winpop", gl_winpop},
+ {"foreground", gl_foreground},
+ {"endfullscrn", gl_endfullscrn},
+ {"endpupmode", gl_endpupmode},
+ {"fullscrn", gl_fullscrn},
+ {"pupmode", gl_pupmode},
+ {"winconstraints", gl_winconstraints},
+ {"pagecolor", gl_pagecolor},
+ {"textcolor", gl_textcolor},
+ {"color", gl_color},
+ {"curveit", gl_curveit},
+ {"font", gl_font},
+ {"linewidth", gl_linewidth},
+ {"setlinestyle", gl_setlinestyle},
+ {"setmap", gl_setmap},
+ {"swapinterval", gl_swapinterval},
+ {"writemask", gl_writemask},
+ {"textwritemask", gl_textwritemask},
+ {"qdevice", gl_qdevice},
+ {"unqdevice", gl_unqdevice},
+ {"curvebasis", gl_curvebasis},
+ {"curveprecision", gl_curveprecision},
+ {"loadname", gl_loadname},
+ {"passthrough", gl_passthrough},
+ {"pushname", gl_pushname},
+ {"setmonitor", gl_setmonitor},
+ {"setshade", gl_setshade},
+ {"setpattern", gl_setpattern},
+ {"pagewritemask", gl_pagewritemask},
+ {"callobj", gl_callobj},
+ {"delobj", gl_delobj},
+ {"editobj", gl_editobj},
+ {"makeobj", gl_makeobj},
+ {"maketag", gl_maketag},
+ {"chunksize", gl_chunksize},
+ {"compactify", gl_compactify},
+ {"deltag", gl_deltag},
+ {"lsrepeat", gl_lsrepeat},
+ {"objinsert", gl_objinsert},
+ {"objreplace", gl_objreplace},
+ {"winclose", gl_winclose},
+ {"blanktime", gl_blanktime},
+ {"freepup", gl_freepup},
+ {"backbuffer", gl_backbuffer},
+ {"frontbuffer", gl_frontbuffer},
+ {"lsbackup", gl_lsbackup},
+ {"resetls", gl_resetls},
+ {"lampon", gl_lampon},
+ {"lampoff", gl_lampoff},
+ {"setbell", gl_setbell},
+ {"blankscreen", gl_blankscreen},
+ {"depthcue", gl_depthcue},
+ {"zbuffer", gl_zbuffer},
+ {"backface", gl_backface},
+ {"cmov2i", gl_cmov2i},
+ {"draw2i", gl_draw2i},
+ {"move2i", gl_move2i},
+ {"pnt2i", gl_pnt2i},
+ {"patchbasis", gl_patchbasis},
+ {"patchprecision", gl_patchprecision},
+ {"pdr2i", gl_pdr2i},
+ {"pmv2i", gl_pmv2i},
+ {"rpdr2i", gl_rpdr2i},
+ {"rpmv2i", gl_rpmv2i},
+ {"xfpt2i", gl_xfpt2i},
+ {"objdelete", gl_objdelete},
+ {"patchcurves", gl_patchcurves},
+ {"minsize", gl_minsize},
+ {"maxsize", gl_maxsize},
+ {"keepaspect", gl_keepaspect},
+ {"prefsize", gl_prefsize},
+ {"stepunit", gl_stepunit},
+ {"fudge", gl_fudge},
+ {"winmove", gl_winmove},
+ {"attachcursor", gl_attachcursor},
+ {"deflinestyle", gl_deflinestyle},
+ {"noise", gl_noise},
+ {"picksize", gl_picksize},
+ {"qenter", gl_qenter},
+ {"setdepth", gl_setdepth},
+ {"cmov2s", gl_cmov2s},
+ {"draw2s", gl_draw2s},
+ {"move2s", gl_move2s},
+ {"pdr2s", gl_pdr2s},
+ {"pmv2s", gl_pmv2s},
+ {"pnt2s", gl_pnt2s},
+ {"rdr2s", gl_rdr2s},
+ {"rmv2s", gl_rmv2s},
+ {"rpdr2s", gl_rpdr2s},
+ {"rpmv2s", gl_rpmv2s},
+ {"xfpt2s", gl_xfpt2s},
+ {"cmov2", gl_cmov2},
+ {"draw2", gl_draw2},
+ {"move2", gl_move2},
+ {"pnt2", gl_pnt2},
+ {"pdr2", gl_pdr2},
+ {"pmv2", gl_pmv2},
+ {"rdr2", gl_rdr2},
+ {"rmv2", gl_rmv2},
+ {"rpdr2", gl_rpdr2},
+ {"rpmv2", gl_rpmv2},
+ {"xfpt2", gl_xfpt2},
+ {"loadmatrix", gl_loadmatrix},
+ {"multmatrix", gl_multmatrix},
+ {"crv", gl_crv},
+ {"rcrv", gl_rcrv},
+ {"addtopup", gl_addtopup},
+ {"charstr", gl_charstr},
+ {"getport", gl_getport},
+ {"strwidth", gl_strwidth},
+ {"winopen", gl_winopen},
+ {"wintitle", gl_wintitle},
+ {"polf", gl_polf},
+ {"polf2", gl_polf2},
+ {"poly", gl_poly},
+ {"poly2", gl_poly2},
+ {"crvn", gl_crvn},
+ {"rcrvn", gl_rcrvn},
+ {"polf2i", gl_polf2i},
+ {"polfi", gl_polfi},
+ {"poly2i", gl_poly2i},
+ {"polyi", gl_polyi},
+ {"polf2s", gl_polf2s},
+ {"polfs", gl_polfs},
+ {"polys", gl_polys},
+ {"poly2s", gl_poly2s},
+ {"defcursor", gl_defcursor},
+ {"writepixels", gl_writepixels},
+ {"defbasis", gl_defbasis},
+ {"gewrite", gl_gewrite},
+ {"rotate", gl_rotate},
+ {"rot", gl_rot},
+ {"circfi", gl_circfi},
+ {"circi", gl_circi},
+ {"cmovi", gl_cmovi},
+ {"drawi", gl_drawi},
+ {"movei", gl_movei},
+ {"pnti", gl_pnti},
+ {"newtag", gl_newtag},
+ {"pdri", gl_pdri},
+ {"pmvi", gl_pmvi},
+ {"rdri", gl_rdri},
+ {"rmvi", gl_rmvi},
+ {"rpdri", gl_rpdri},
+ {"rpmvi", gl_rpmvi},
+ {"xfpti", gl_xfpti},
+ {"circ", gl_circ},
+ {"circf", gl_circf},
+ {"cmov", gl_cmov},
+ {"draw", gl_draw},
+ {"move", gl_move},
+ {"pnt", gl_pnt},
+ {"scale", gl_scale},
+ {"translate", gl_translate},
+ {"pdr", gl_pdr},
+ {"pmv", gl_pmv},
+ {"rdr", gl_rdr},
+ {"rmv", gl_rmv},
+ {"rpdr", gl_rpdr},
+ {"rpmv", gl_rpmv},
+ {"xfpt", gl_xfpt},
+ {"RGBcolor", gl_RGBcolor},
+ {"RGBwritemask", gl_RGBwritemask},
+ {"setcursor", gl_setcursor},
+ {"tie", gl_tie},
+ {"circfs", gl_circfs},
+ {"circs", gl_circs},
+ {"cmovs", gl_cmovs},
+ {"draws", gl_draws},
+ {"moves", gl_moves},
+ {"pdrs", gl_pdrs},
+ {"pmvs", gl_pmvs},
+ {"pnts", gl_pnts},
+ {"rdrs", gl_rdrs},
+ {"rmvs", gl_rmvs},
+ {"rpdrs", gl_rpdrs},
+ {"rpmvs", gl_rpmvs},
+ {"xfpts", gl_xfpts},
+ {"curorigin", gl_curorigin},
+ {"cyclemap", gl_cyclemap},
+ {"patch", gl_patch},
+ {"splf", gl_splf},
+ {"splf2", gl_splf2},
+ {"splfi", gl_splfi},
+ {"splf2i", gl_splf2i},
+ {"splfs", gl_splfs},
+ {"splf2s", gl_splf2s},
+ {"rpatch", gl_rpatch},
+ {"ortho2", gl_ortho2},
+ {"rect", gl_rect},
+ {"rectf", gl_rectf},
+ {"xfpt4", gl_xfpt4},
+ {"textport", gl_textport},
+ {"mapcolor", gl_mapcolor},
+ {"scrmask", gl_scrmask},
+ {"setvaluator", gl_setvaluator},
+ {"viewport", gl_viewport},
+ {"shaderange", gl_shaderange},
+ {"xfpt4s", gl_xfpt4s},
+ {"rectfi", gl_rectfi},
+ {"recti", gl_recti},
+ {"xfpt4i", gl_xfpt4i},
+ {"prefposition", gl_prefposition},
+ {"arc", gl_arc},
+ {"arcf", gl_arcf},
+ {"arcfi", gl_arcfi},
+ {"arci", gl_arci},
+ {"bbox2", gl_bbox2},
+ {"bbox2i", gl_bbox2i},
+ {"bbox2s", gl_bbox2s},
+ {"blink", gl_blink},
+ {"ortho", gl_ortho},
+ {"window", gl_window},
+ {"lookat", gl_lookat},
+ {"perspective", gl_perspective},
+ {"polarview", gl_polarview},
+ {"arcfs", gl_arcfs},
+ {"arcs", gl_arcs},
+ {"rectcopy", gl_rectcopy},
+ {"RGBcursor", gl_RGBcursor},
+ {"getbutton", gl_getbutton},
+ {"getcmmode", gl_getcmmode},
+ {"getlsbackup", gl_getlsbackup},
+ {"getresetls", gl_getresetls},
+ {"getdcm", gl_getdcm},
+ {"getzbuffer", gl_getzbuffer},
+ {"ismex", gl_ismex},
+ {"isobj", gl_isobj},
+ {"isqueued", gl_isqueued},
+ {"istag", gl_istag},
+ {"genobj", gl_genobj},
+ {"gentag", gl_gentag},
+ {"getbuffer", gl_getbuffer},
+ {"getcolor", gl_getcolor},
+ {"getdisplaymode", gl_getdisplaymode},
+ {"getfont", gl_getfont},
+ {"getheight", gl_getheight},
+ {"gethitcode", gl_gethitcode},
+ {"getlstyle", gl_getlstyle},
+ {"getlwidth", gl_getlwidth},
+ {"getmap", gl_getmap},
+ {"getplanes", gl_getplanes},
+ {"getwritemask", gl_getwritemask},
+ {"qtest", gl_qtest},
+ {"getlsrepeat", gl_getlsrepeat},
+ {"getmonitor", gl_getmonitor},
+ {"getopenobj", gl_getopenobj},
+ {"getpattern", gl_getpattern},
+ {"winget", gl_winget},
+ {"winattach", gl_winattach},
+ {"getothermonitor", gl_getothermonitor},
+ {"newpup", gl_newpup},
+ {"getvaluator", gl_getvaluator},
+ {"winset", gl_winset},
+ {"dopup", gl_dopup},
+ {"getdepth", gl_getdepth},
+ {"getcpos", gl_getcpos},
+ {"getsize", gl_getsize},
+ {"getorigin", gl_getorigin},
+ {"getviewport", gl_getviewport},
+ {"gettp", gl_gettp},
+ {"getgpos", gl_getgpos},
+ {"winposition", gl_winposition},
+ {"gRGBcolor", gl_gRGBcolor},
+ {"gRGBmask", gl_gRGBmask},
+ {"getscrmask", gl_getscrmask},
+ {"getmcolor", gl_getmcolor},
+ {"mapw", gl_mapw},
+ {"mapw2", gl_mapw2},
+ {"getcursor", gl_getcursor},
+ {"cmode", gl_cmode},
+ {"concave", gl_concave},
+ {"curstype", gl_curstype},
+ {"drawmode", gl_drawmode},
+ {"gammaramp", gl_gammaramp},
+ {"getbackface", gl_getbackface},
+ {"getdescender", gl_getdescender},
+ {"getdrawmode", gl_getdrawmode},
+ {"getmmode", gl_getmmode},
+ {"getsm", gl_getsm},
+ {"getvideo", gl_getvideo},
+ {"imakebackground", gl_imakebackground},
+ {"lmbind", gl_lmbind},
+ {"lmdef", gl_lmdef},
+ {"mmode", gl_mmode},
+ {"normal", gl_normal},
+ {"overlay", gl_overlay},
+ {"RGBrange", gl_RGBrange},
+ {"setvideo", gl_setvideo},
+ {"shademodel", gl_shademodel},
+ {"underlay", gl_underlay},
+ {"bgnclosedline", gl_bgnclosedline},
+ {"bgnline", gl_bgnline},
+ {"bgnpoint", gl_bgnpoint},
+ {"bgnpolygon", gl_bgnpolygon},
+ {"bgnsurface", gl_bgnsurface},
+ {"bgntmesh", gl_bgntmesh},
+ {"bgntrim", gl_bgntrim},
+ {"endclosedline", gl_endclosedline},
+ {"endline", gl_endline},
+ {"endpoint", gl_endpoint},
+ {"endpolygon", gl_endpolygon},
+ {"endsurface", gl_endsurface},
+ {"endtmesh", gl_endtmesh},
+ {"endtrim", gl_endtrim},
+ {"blendfunction", gl_blendfunction},
+ {"c3f", gl_c3f},
+ {"c3i", gl_c3i},
+ {"c3s", gl_c3s},
+ {"c4f", gl_c4f},
+ {"c4i", gl_c4i},
+ {"c4s", gl_c4s},
+ {"colorf", gl_colorf},
+ {"cpack", gl_cpack},
+ {"czclear", gl_czclear},
+ {"dglclose", gl_dglclose},
+ {"dglopen", gl_dglopen},
+ {"getgdesc", gl_getgdesc},
+ {"getnurbsproperty", gl_getnurbsproperty},
+ {"glcompat", gl_glcompat},
+ {"iconsize", gl_iconsize},
+ {"icontitle", gl_icontitle},
+ {"lRGBrange", gl_lRGBrange},
+ {"linesmooth", gl_linesmooth},
+ {"lmcolor", gl_lmcolor},
+ {"logicop", gl_logicop},
+ {"lsetdepth", gl_lsetdepth},
+ {"lshaderange", gl_lshaderange},
+ {"n3f", gl_n3f},
+ {"noborder", gl_noborder},
+ {"pntsmooth", gl_pntsmooth},
+ {"readsource", gl_readsource},
+ {"rectzoom", gl_rectzoom},
+ {"sbox", gl_sbox},
+ {"sboxi", gl_sboxi},
+ {"sboxs", gl_sboxs},
+ {"sboxf", gl_sboxf},
+ {"sboxfi", gl_sboxfi},
+ {"sboxfs", gl_sboxfs},
+ {"setnurbsproperty", gl_setnurbsproperty},
+ {"setpup", gl_setpup},
+ {"smoothline", gl_smoothline},
+ {"subpixel", gl_subpixel},
+ {"swaptmesh", gl_swaptmesh},
+ {"swinopen", gl_swinopen},
+ {"v2f", gl_v2f},
+ {"v2i", gl_v2i},
+ {"v2s", gl_v2s},
+ {"v3f", gl_v3f},
+ {"v3i", gl_v3i},
+ {"v3s", gl_v3s},
+ {"v4f", gl_v4f},
+ {"v4i", gl_v4i},
+ {"v4s", gl_v4s},
+ {"videocmd", gl_videocmd},
+ {"windepth", gl_windepth},
+ {"wmpack", gl_wmpack},
+ {"zdraw", gl_zdraw},
+ {"zfunction", gl_zfunction},
+ {"zsource", gl_zsource},
+ {"zwritemask", gl_zwritemask},
+ {"v2d", gl_v2d},
+ {"v3d", gl_v3d},
+ {"v4d", gl_v4d},
+ {"pixmode", gl_pixmode},
+ {"qgetfd", gl_qgetfd},
+ {"dither", gl_dither},
+ {NULL, NULL} /* Sentinel */
+};
+
+void
+initgl()
+{
+ Py_InitModule("gl", gl_methods);
+}
projects / python / commitdiff