source: python/trunk/Modules/glmodule.c

Last change on this file was 391, checked in by dmik, 11 years ago

python: Merge vendor 2.7.6 to trunk.
  • Property svn:eol-style set to native
File size: 176.4 KB
RevLine 
[2]1
2/*
3Input used to generate the Python module "glmodule.c".
4The stub generator is a Python script called "cgen.py".
5
6Each definition must be contained on one line:
7
8<returntype> <name> <type> <arg> <type> <arg>
9
10<returntype> can be: void, short, long (XXX maybe others?)
11
12<type> can be: char, string, short, float, long, or double
[391]13 string indicates a null terminated string;
14 if <type> is char and <arg> begins with a *, the * is stripped
15 and <type> is changed into string
[2]16
17<arg> has the form <mode> or <mode>[<subscript>]
[391]18 where <mode> can be
19 s: arg is sent
20 r: arg is received (arg is a pointer)
21 and <subscript> can be (N and I are numbers):
22 N
23 argI
24 retval
25 N*argI
26 N*I
27 N*retval
28 In the case where the subscript consists of two parts
29 separated by *, the first part is the width of the matrix, and
30 the second part is the length of the matrix. This order is
31 opposite from the order used in C to declare a two-dimensional
32 matrix.
[2]33*/
34
35/*
36 * An attempt has been made to make this module switch threads on qread
37 * calls. It is far from safe, though.
38 */
39
40#include <gl.h>
41#include <device.h>
42
43#ifdef __sgi
44extern int devport();
45extern int textwritemask();
46extern int pagewritemask();
47extern int gewrite();
48extern int gettp();
49#endif
50
51#include "Python.h"
52#include "cgensupport.h"
53
54/*
55Some stubs are too complicated for the stub generator.
56We can include manually written versions of them here.
57A line starting with '%' gives the name of the function so the stub
58generator can include it in the table of functions.
59*/
60
61
62static PyObject *
63gl_qread(PyObject *self, PyObject *args)
64{
[391]65 long retval;
66 short arg1 ;
67 Py_BEGIN_ALLOW_THREADS
68 retval = qread( & arg1 );
69 Py_END_ALLOW_THREADS
70 { PyObject *v = PyTuple_New( 2 );
71 if (v == NULL) return NULL;
72 PyTuple_SetItem(v, 0, mknewlongobject(retval));
73 PyTuple_SetItem(v, 1, mknewshortobject(arg1));
74 return v;
75 }
[2]76}
77
78
79/*
80varray -- an array of v.. calls.
81The argument is an array (maybe list or tuple) of points.
82Each point must be a tuple or list of coordinates (x, y, z).
83The points may be 2- or 3-dimensional but must all have the
84same dimension. Float and int values may be mixed however.
85The points are always converted to 3D double precision points
86by assuming z=0.0 if necessary (as indicated in the man page),
87and for each point v3d() is called.
88*/
89
90
91static PyObject *
92gl_varray(PyObject *self, PyObject *args)
93{
[391]94 PyObject *v, *w=NULL;
95 int i, n, width;
96 double vec[3];
97 PyObject * (*getitem)(PyObject *, int);
98
99 if (!PyArg_GetObject(args, 1, 0, &v))
100 return NULL;
101
102 if (PyList_Check(v)) {
103 n = PyList_Size(v);
104 getitem = PyList_GetItem;
105 }
106 else if (PyTuple_Check(v)) {
107 n = PyTuple_Size(v);
108 getitem = PyTuple_GetItem;
109 }
110 else {
111 PyErr_BadArgument();
112 return NULL;
113 }
114
115 if (n == 0) {
116 Py_INCREF(Py_None);
117 return Py_None;
118 }
119 if (n > 0)
120 w = (*getitem)(v, 0);
121
122 width = 0;
123 if (w == NULL) {
124 }
125 else if (PyList_Check(w)) {
126 width = PyList_Size(w);
127 }
128 else if (PyTuple_Check(w)) {
129 width = PyTuple_Size(w);
130 }
131
132 switch (width) {
133 case 2:
134 vec[2] = 0.0;
135 /* Fall through */
136 case 3:
137 break;
138 default:
139 PyErr_BadArgument();
140 return NULL;
141 }
142
143 for (i = 0; i < n; i++) {
144 w = (*getitem)(v, i);
145 if (!PyArg_GetDoubleArray(w, 1, 0, width, vec))
146 return NULL;
147 v3d(vec);
148 }
149
150 Py_INCREF(Py_None);
151 return Py_None;
[2]152}
153
154/*
155vnarray, nvarray -- an array of n3f and v3f calls.
156The argument is an array (list or tuple) of pairs of points and normals.
157Each pair is a tuple (NOT a list) of a point and a normal for that point.
158Each point or normal must be a tuple (NOT a list) of coordinates (x, y, z).
159Three coordinates must be given. Float and int values may be mixed.
160For each pair, n3f() is called for the normal, and then v3f() is called
161for the vector.
162
163vnarray and nvarray differ only in the order of the vector and normal in
164the pair: vnarray expects (v, n) while nvarray expects (n, v).
165*/
166
167static PyObject *gen_nvarray(); /* Forward */
168
169
170static PyObject *
171gl_nvarray(PyObject *self, PyObject *args)
172{
[391]173 return gen_nvarray(args, 0);
[2]174}
175
176
177static PyObject *
178gl_vnarray(PyObject *self, PyObject *args)
179{
[391]180 return gen_nvarray(args, 1);
[2]181}
182
183/* Generic, internal version of {nv,nv}array: inorm indicates the
184 argument order, 0: normal first, 1: vector first. */
185
186static PyObject *
187gen_nvarray(PyObject *args, int inorm)
188{
[391]189 PyObject *v, *w, *wnorm, *wvec;
190 int i, n;
191 float norm[3], vec[3];
192 PyObject * (*getitem)(PyObject *, int);
193
194 if (!PyArg_GetObject(args, 1, 0, &v))
195 return NULL;
196
197 if (PyList_Check(v)) {
198 n = PyList_Size(v);
199 getitem = PyList_GetItem;
200 }
201 else if (PyTuple_Check(v)) {
202 n = PyTuple_Size(v);
203 getitem = PyTuple_GetItem;
204 }
205 else {
206 PyErr_BadArgument();
207 return NULL;
208 }
209
210 for (i = 0; i < n; i++) {
211 w = (*getitem)(v, i);
212 if (!PyTuple_Check(w) || PyTuple_Size(w) != 2) {
213 PyErr_BadArgument();
214 return NULL;
215 }
216 wnorm = PyTuple_GetItem(w, inorm);
217 wvec = PyTuple_GetItem(w, 1 - inorm);
218 if (!PyArg_GetFloatArray(wnorm, 1, 0, 3, norm) ||
219 !PyArg_GetFloatArray(wvec, 1, 0, 3, vec))
220 return NULL;
221 n3f(norm);
222 v3f(vec);
223 }
224
225 Py_INCREF(Py_None);
226 return Py_None;
[2]227}
228
229/* nurbssurface(s_knots[], t_knots[], ctl[][], s_order, t_order, type).
230 The dimensions of ctl[] are computed as follows:
231 [len(s_knots) - s_order], [len(t_knots) - t_order]
232*/
233
234
235static PyObject *
236gl_nurbssurface(PyObject *self, PyObject *args)
237{
[391]238 long arg1 ;
239 double * arg2 ;
240 long arg3 ;
241 double * arg4 ;
242 double *arg5 ;
243 long arg6 ;
244 long arg7 ;
245 long arg8 ;
246 long ncoords;
247 long s_byte_stride, t_byte_stride;
248 long s_nctl, t_nctl;
249 long s, t;
250 PyObject *v, *w, *pt;
251 double *pnext;
252 if (!PyArg_GetLongArraySize(args, 6, 0, &arg1))
253 return NULL;
254 if ((arg2 = PyMem_NEW(double, arg1 )) == NULL) {
255 return PyErr_NoMemory();
256 }
257 if (!PyArg_GetDoubleArray(args, 6, 0, arg1 , arg2))
258 return NULL;
259 if (!PyArg_GetLongArraySize(args, 6, 1, &arg3))
260 return NULL;
261 if ((arg4 = PyMem_NEW(double, arg3 )) == NULL) {
262 return PyErr_NoMemory();
263 }
264 if (!PyArg_GetDoubleArray(args, 6, 1, arg3 , arg4))
265 return NULL;
266 if (!PyArg_GetLong(args, 6, 3, &arg6))
267 return NULL;
268 if (!PyArg_GetLong(args, 6, 4, &arg7))
269 return NULL;
270 if (!PyArg_GetLong(args, 6, 5, &arg8))
271 return NULL;
272 if (arg8 == N_XYZ)
273 ncoords = 3;
274 else if (arg8 == N_XYZW)
275 ncoords = 4;
276 else {
277 PyErr_BadArgument();
278 return NULL;
279 }
280 s_nctl = arg1 - arg6;
281 t_nctl = arg3 - arg7;
282 if (!PyArg_GetObject(args, 6, 2, &v))
283 return NULL;
284 if (!PyList_Check(v) || PyList_Size(v) != s_nctl) {
285 PyErr_BadArgument();
286 return NULL;
287 }
288 if ((arg5 = PyMem_NEW(double, s_nctl*t_nctl*ncoords )) == NULL) {
289 return PyErr_NoMemory();
290 }
291 pnext = arg5;
292 for (s = 0; s < s_nctl; s++) {
293 w = PyList_GetItem(v, s);
294 if (w == NULL || !PyList_Check(w) ||
295 PyList_Size(w) != t_nctl) {
296 PyErr_BadArgument();
297 return NULL;
298 }
299 for (t = 0; t < t_nctl; t++) {
300 pt = PyList_GetItem(w, t);
301 if (!PyArg_GetDoubleArray(pt, 1, 0, ncoords, pnext))
302 return NULL;
303 pnext += ncoords;
304 }
305 }
306 s_byte_stride = sizeof(double) * ncoords;
307 t_byte_stride = s_byte_stride * s_nctl;
308 nurbssurface( arg1 , arg2 , arg3 , arg4 ,
309 s_byte_stride , t_byte_stride , arg5 , arg6 , arg7 , arg8 );
310 PyMem_DEL(arg2);
311 PyMem_DEL(arg4);
312 PyMem_DEL(arg5);
313 Py_INCREF(Py_None);
314 return Py_None;
[2]315}
316
317/* nurbscurve(knots, ctlpoints, order, type).
318 The length of ctlpoints is len(knots)-order. */
319
320
321static PyObject *
322gl_nurbscurve(PyObject *self, PyObject *args)
323{
[391]324 long arg1 ;
325 double * arg2 ;
326 long arg3 ;
327 double * arg4 ;
328 long arg5 ;
329 long arg6 ;
330 int ncoords, npoints;
331 int i;
332 PyObject *v;
333 double *pnext;
334 if (!PyArg_GetLongArraySize(args, 4, 0, &arg1))
335 return NULL;
336 if ((arg2 = PyMem_NEW(double, arg1 )) == NULL) {
337 return PyErr_NoMemory();
338 }
339 if (!PyArg_GetDoubleArray(args, 4, 0, arg1 , arg2))
340 return NULL;
341 if (!PyArg_GetLong(args, 4, 2, &arg5))
342 return NULL;
343 if (!PyArg_GetLong(args, 4, 3, &arg6))
344 return NULL;
345 if (arg6 == N_ST)
346 ncoords = 2;
347 else if (arg6 == N_STW)
348 ncoords = 3;
349 else {
350 PyErr_BadArgument();
351 return NULL;
352 }
353 npoints = arg1 - arg5;
354 if (!PyArg_GetObject(args, 4, 1, &v))
355 return NULL;
356 if (!PyList_Check(v) || PyList_Size(v) != npoints) {
357 PyErr_BadArgument();
358 return NULL;
359 }
360 if ((arg4 = PyMem_NEW(double, npoints*ncoords )) == NULL) {
361 return PyErr_NoMemory();
362 }
363 pnext = arg4;
364 for (i = 0; i < npoints; i++) {
365 if (!PyArg_GetDoubleArray(PyList_GetItem(v, i), 1, 0, ncoords, pnext))
366 return NULL;
367 pnext += ncoords;
368 }
369 arg3 = (sizeof(double)) * ncoords;
370 nurbscurve( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 );
371 PyMem_DEL(arg2);
372 PyMem_DEL(arg4);
373 Py_INCREF(Py_None);
374 return Py_None;
[2]375}
376
377/* pwlcurve(points, type).
378 Points is a list of points. Type must be N_ST. */
379
380
381static PyObject *
382gl_pwlcurve(PyObject *self, PyObject *args)
383{
[391]384 PyObject *v;
385 long type;
386 double *data, *pnext;
387 long npoints, ncoords;
388 int i;
389 if (!PyArg_GetObject(args, 2, 0, &v))
390 return NULL;
391 if (!PyArg_GetLong(args, 2, 1, &type))
392 return NULL;
393 if (!PyList_Check(v)) {
394 PyErr_BadArgument();
395 return NULL;
396 }
397 npoints = PyList_Size(v);
398 if (type == N_ST)
399 ncoords = 2;
400 else {
401 PyErr_BadArgument();
402 return NULL;
403 }
404 if ((data = PyMem_NEW(double, npoints*ncoords)) == NULL) {
405 return PyErr_NoMemory();
406 }
407 pnext = data;
408 for (i = 0; i < npoints; i++) {
409 if (!PyArg_GetDoubleArray(PyList_GetItem(v, i), 1, 0, ncoords, pnext))
410 return NULL;
411 pnext += ncoords;
412 }
413 pwlcurve(npoints, data, sizeof(double)*ncoords, type);
414 PyMem_DEL(data);
415 Py_INCREF(Py_None);
416 return Py_None;
[2]417}
418
419
420/* Picking and Selecting */
421
422static short *pickbuffer = NULL;
423static long pickbuffersize;
424
425static PyObject *
426pick_select(PyObject *args, void (*func)())
427{
[391]428 if (!PyArg_GetLong(args, 1, 0, &pickbuffersize))
429 return NULL;
430 if (pickbuffer != NULL) {
431 PyErr_SetString(PyExc_RuntimeError,
432 "pick/gselect: already picking/selecting");
433 return NULL;
434 }
435 if ((pickbuffer = PyMem_NEW(short, pickbuffersize)) == NULL) {
436 return PyErr_NoMemory();
437 }
438 (*func)(pickbuffer, pickbuffersize);
439 Py_INCREF(Py_None);
440 return Py_None;
[2]441}
442
443static PyObject *
444endpick_select(long (*func)())
445{
[391]446 PyObject *v, *w;
447 int i, nhits, n;
448 if (pickbuffer == NULL) {
449 PyErr_SetString(PyExc_RuntimeError,
450 "endpick/endselect: not in pick/select mode");
451 return NULL;
452 }
453 nhits = (*func)(pickbuffer);
454 if (nhits < 0) {
455 nhits = -nhits; /* How to report buffer overflow otherwise? */
456 }
457 /* Scan the buffer to see how many integers */
458 n = 0;
459 for (; nhits > 0; nhits--) {
460 n += 1 + pickbuffer[n];
461 }
462 v = PyList_New(n);
463 if (v == NULL)
464 return NULL;
465 /* XXX Could do it nicer and interpret the data structure here,
466 returning a list of lists. But this can be done in Python... */
467 for (i = 0; i < n; i++) {
468 w = PyInt_FromLong((long)pickbuffer[i]);
469 if (w == NULL) {
470 Py_DECREF(v);
471 return NULL;
472 }
473 PyList_SetItem(v, i, w);
474 }
475 PyMem_DEL(pickbuffer);
476 pickbuffer = NULL;
477 return v;
[2]478}
479
480extern void pick(), gselect();
481extern long endpick(), endselect();
482
483static PyObject *gl_pick(PyObject *self, PyObject *args)
484{
[391]485 return pick_select(args, pick);
[2]486}
487
488static PyObject *gl_endpick(PyObject *self)
489{
[391]490 return endpick_select(endpick);
[2]491}
492
493static PyObject *gl_gselect(PyObject *self, PyObject *args)
494{
[391]495 return pick_select(args, gselect);
[2]496}
497
498static PyObject *gl_endselect(PyObject *self)
499{
[391]500 return endpick_select(endselect);
[2]501}
502
503
504/* XXX The generator botches this one. Here's a quick hack to fix it. */
505
506/* XXX The generator botches this one. Here's a quick hack to fix it. */
507
508
509static PyObject *
510gl_getmatrix(PyObject *self, PyObject *args)
511{
[391]512 Matrix arg1;
513 PyObject *v, *w;
514 int i, j;
515 getmatrix( arg1 );
516 v = PyList_New(16);
517 if (v == NULL) {
518 return PyErr_NoMemory();
519 }
520 for (i = 0; i < 4; i++) for (j = 0; j < 4; j++) {
521 w = mknewfloatobject(arg1[i][j]);
522 if (w == NULL) {
523 Py_DECREF(v);
524 return NULL;
525 }
526 PyList_SetItem(v, i*4+j, w);
527 }
528 return v;
[2]529}
530
531/* Here's an alternate version that returns a 4x4 matrix instead of
532 a vector. Unfortunately it is incompatible with loadmatrix and
533 multmatrix... */
534
535
536static PyObject *
537gl_altgetmatrix(PyObject *self, PyObject *args)
538{
[391]539 Matrix arg1;
540 PyObject *v, *w;
541 int i, j;
542 getmatrix( arg1 );
543 v = PyList_New(4);
544 if (v == NULL) {
545 return NULL;
546 }
547 for (i = 0; i < 4; i++) {
548 w = PyList_New(4);
549 if (w == NULL) {
550 Py_DECREF(v);
551 return NULL;
552 }
553 PyList_SetItem(v, i, w);
554 }
555 for (i = 0; i < 4; i++) {
556 for (j = 0; j < 4; j++) {
557 w = mknewfloatobject(arg1[i][j]);
558 if (w == NULL) {
559 Py_DECREF(v);
560 return NULL;
561 }
562 PyList_SetItem(PyList_GetItem(v, i), j, w);
563 }
564 }
565 return v;
[2]566}
567
568
569static PyObject *
570gl_lrectwrite(PyObject *self, PyObject *args)
571{
[391]572 short x1 ;
573 short y1 ;
574 short x2 ;
575 short y2 ;
576 string parray ;
577 PyObject *s;
[2]578#if 0
[391]579 int pixcount;
[2]580#endif
[391]581 if (!PyArg_GetShort(args, 5, 0, &x1))
582 return NULL;
583 if (!PyArg_GetShort(args, 5, 1, &y1))
584 return NULL;
585 if (!PyArg_GetShort(args, 5, 2, &x2))
586 return NULL;
587 if (!PyArg_GetShort(args, 5, 3, &y2))
588 return NULL;
589 if (!PyArg_GetString(args, 5, 4, &parray))
590 return NULL;
591 if (!PyArg_GetObject(args, 5, 4, &s))
592 return NULL;
[2]593#if 0
594/* Don't check this, it breaks experiments with pixmode(PM_SIZE, ...) */
[391]595 pixcount = (long)(x2+1-x1) * (long)(y2+1-y1);
596 if (!PyString_Check(s) || PyString_Size(s) != pixcount*sizeof(long)) {
597 PyErr_SetString(PyExc_RuntimeError,
598 "string arg to lrectwrite has wrong size");
599 return NULL;
600 }
[2]601#endif
[391]602 lrectwrite( x1 , y1 , x2 , y2 , (unsigned long *) parray );
603 Py_INCREF(Py_None);
604 return Py_None;
[2]605}
606
607
608static PyObject *
609gl_lrectread(PyObject *self, PyObject *args)
610{
[391]611 short x1 ;
612 short y1 ;
613 short x2 ;
614 short y2 ;
615 PyObject *parray;
616 int pixcount;
617 if (!PyArg_GetShort(args, 4, 0, &x1))
618 return NULL;
619 if (!PyArg_GetShort(args, 4, 1, &y1))
620 return NULL;
621 if (!PyArg_GetShort(args, 4, 2, &x2))
622 return NULL;
623 if (!PyArg_GetShort(args, 4, 3, &y2))
624 return NULL;
625 pixcount = (long)(x2+1-x1) * (long)(y2+1-y1);
626 parray = PyString_FromStringAndSize((char *)NULL, pixcount*sizeof(long));
627 if (parray == NULL)
628 return NULL; /* No memory */
629 lrectread(x1, y1, x2, y2, (unsigned long *) PyString_AsString(parray));
630 return parray;
[2]631}
632
633
634static PyObject *
635gl_readdisplay(PyObject *self, PyObject *args)
636{
[391]637 short x1, y1, x2, y2;
638 unsigned long *parray, hints;
639 long size, size_ret;
640 PyObject *rv;
[2]641
[391]642 if ( !PyArg_Parse(args, "hhhhl", &x1, &y1, &x2, &y2, &hints) )
643 return 0;
644 size = (long)(x2+1-x1) * (long)(y2+1-y1);
645 rv = PyString_FromStringAndSize((char *)NULL, size*sizeof(long));
646 if ( rv == NULL )
647 return NULL;
648 parray = (unsigned long *)PyString_AsString(rv);
649 size_ret = readdisplay(x1, y1, x2, y2, parray, hints);
650 if ( size_ret != size ) {
651 printf("gl_readdisplay: got %ld pixels, expected %ld\n",
652 size_ret, size);
653 PyErr_SetString(PyExc_RuntimeError, "readdisplay returned unexpected length");
654 return NULL;
655 }
656 return rv;
[2]657}
658
659/* Desperately needed, here are tools to compress and decompress
660 the data manipulated by lrectread/lrectwrite.
661
662 gl.packrect(width, height, packfactor, bigdata) --> smalldata
[391]663 makes 'bigdata' 4*(packfactor**2) times smaller by:
664 - turning it into B/W (a factor 4)
665 - replacing squares of size pacfactor by one
666 representative
[2]667
668 gl.unpackrect(width, height, packfactor, smalldata) --> bigdata
[391]669 is the inverse; the numeric arguments must be *the same*.
[2]670
671 Both work best if width and height are multiples of packfactor
672 (in fact unpackrect will leave garbage bytes).
673*/
674
675
676static PyObject *
677gl_packrect(PyObject *self, PyObject *args)
678{
[391]679 long width, height, packfactor;
680 char *s;
681 PyObject *unpacked, *packed;
682 int pixcount, packedcount, x, y, r, g, b;
683 unsigned long pixel;
684 unsigned char *p;
685 unsigned long *parray;
686 if (!PyArg_GetLong(args, 4, 0, &width))
687 return NULL;
688 if (!PyArg_GetLong(args, 4, 1, &height))
689 return NULL;
690 if (!PyArg_GetLong(args, 4, 2, &packfactor))
691 return NULL;
692 if (!PyArg_GetString(args, 4, 3, &s)) /* For type checking only */
693 return NULL;
694 if (!PyArg_GetObject(args, 4, 3, &unpacked))
695 return NULL;
696 if (width <= 0 || height <= 0 || packfactor <= 0) {
697 PyErr_SetString(PyExc_RuntimeError, "packrect args must be > 0");
698 return NULL;
699 }
700 pixcount = width*height;
701 packedcount = ((width+packfactor-1)/packfactor) *
702 ((height+packfactor-1)/packfactor);
703 if (PyString_Size(unpacked) != pixcount*sizeof(long)) {
704 PyErr_SetString(PyExc_RuntimeError,
705 "string arg to packrect has wrong size");
706 return NULL;
707 }
708 packed = PyString_FromStringAndSize((char *)NULL, packedcount);
709 if (packed == NULL)
710 return NULL;
711 parray = (unsigned long *) PyString_AsString(unpacked);
712 p = (unsigned char *) PyString_AsString(packed);
713 for (y = 0; y < height; y += packfactor, parray += packfactor*width) {
714 for (x = 0; x < width; x += packfactor) {
715 pixel = parray[x];
716 r = pixel & 0xff;
717 g = (pixel >> 8) & 0xff;
718 b = (pixel >> 16) & 0xff;
719 *p++ = (30*r+59*g+11*b) / 100;
720 }
721 }
722 return packed;
[2]723}
724
725
726static unsigned long unpacktab[256];
727static int unpacktab_inited = 0;
728
729static PyObject *
730gl_unpackrect(PyObject *self, PyObject *args)
731{
[391]732 long width, height, packfactor;
733 char *s;
734 PyObject *unpacked, *packed;
735 int pixcount, packedcount;
736 register unsigned char *p;
737 register unsigned long *parray;
738 if (!unpacktab_inited) {
739 register int white;
740 for (white = 256; --white >= 0; )
741 unpacktab[white] = white * 0x010101L;
742 unpacktab_inited++;
743 }
744 if (!PyArg_GetLong(args, 4, 0, &width))
745 return NULL;
746 if (!PyArg_GetLong(args, 4, 1, &height))
747 return NULL;
748 if (!PyArg_GetLong(args, 4, 2, &packfactor))
749 return NULL;
750 if (!PyArg_GetString(args, 4, 3, &s)) /* For type checking only */
751 return NULL;
752 if (!PyArg_GetObject(args, 4, 3, &packed))
753 return NULL;
754 if (width <= 0 || height <= 0 || packfactor <= 0) {
755 PyErr_SetString(PyExc_RuntimeError, "packrect args must be > 0");
756 return NULL;
757 }
758 pixcount = width*height;
759 packedcount = ((width+packfactor-1)/packfactor) *
760 ((height+packfactor-1)/packfactor);
761 if (PyString_Size(packed) != packedcount) {
762 PyErr_SetString(PyExc_RuntimeError,
763 "string arg to unpackrect has wrong size");
764 return NULL;
765 }
766 unpacked = PyString_FromStringAndSize((char *)NULL, pixcount*sizeof(long));
767 if (unpacked == NULL)
768 return NULL;
769 parray = (unsigned long *) PyString_AsString(unpacked);
770 p = (unsigned char *) PyString_AsString(packed);
771 if (packfactor == 1 && width*height > 0) {
772 /* Just expand bytes to longs */
773 register int x = width * height;
774 do {
775 *parray++ = unpacktab[*p++];
776 } while (--x >= 0);
777 }
778 else {
779 register int y;
780 for (y = 0; y < height-packfactor+1;
781 y += packfactor, parray += packfactor*width) {
782 register int x;
783 for (x = 0; x < width-packfactor+1; x += packfactor) {
784 register unsigned long pixel = unpacktab[*p++];
785 register int i;
786 for (i = packfactor*width; (i-=width) >= 0;) {
787 register int j;
788 for (j = packfactor; --j >= 0; )
789 parray[i+x+j] = pixel;
790 }
791 }
792 }
793 }
794 return unpacked;
[2]795}
796
797static PyObject *
798gl_gversion(PyObject *self, PyObject *args)
799{
[391]800 char buf[20];
801 gversion(buf);
802 return PyString_FromString(buf);
[2]803}
804
805
806/* void clear - Manual because of clash with termcap */
807static PyObject *
808gl_clear(PyObject *self, PyObject *args)
809{
[391]810 __GLclear( );
811 Py_INCREF(Py_None);
812 return Py_None;
[2]813}
814
815/* End of manually written stubs */
816
817
818/* long getshade */
819
820static PyObject *
821gl_getshade(PyObject *self, PyObject *args)
822{
[391]823 long retval;
824 retval = getshade( );
825 return mknewlongobject(retval);
[2]826}
827
828/* void devport short s long s */
829
830static PyObject *
831gl_devport(PyObject *self, PyObject *args)
832{
[391]833 short arg1 ;
834 long arg2 ;
835 if (!getishortarg(args, 2, 0, &arg1))
836 return NULL;
837 if (!getilongarg(args, 2, 1, &arg2))
838 return NULL;
839 devport( arg1 , arg2 );
840 Py_INCREF(Py_None);
841 return Py_None;
[2]842}
843
844/* void rdr2i long s long s */
845
846static PyObject *
847gl_rdr2i(PyObject *self, PyObject *args)
848{
[391]849 long arg1 ;
850 long arg2 ;
851 if (!getilongarg(args, 2, 0, &arg1))
852 return NULL;
853 if (!getilongarg(args, 2, 1, &arg2))
854 return NULL;
855 rdr2i( arg1 , arg2 );
856 Py_INCREF(Py_None);
857 return Py_None;
[2]858}
859
860/* void rectfs short s short s short s short s */
861
862static PyObject *
863gl_rectfs(PyObject *self, PyObject *args)
864{
[391]865 short arg1 ;
866 short arg2 ;
867 short arg3 ;
868 short arg4 ;
869 if (!getishortarg(args, 4, 0, &arg1))
870 return NULL;
871 if (!getishortarg(args, 4, 1, &arg2))
872 return NULL;
873 if (!getishortarg(args, 4, 2, &arg3))
874 return NULL;
875 if (!getishortarg(args, 4, 3, &arg4))
876 return NULL;
877 rectfs( arg1 , arg2 , arg3 , arg4 );
878 Py_INCREF(Py_None);
879 return Py_None;
[2]880}
881
882/* void rects short s short s short s short s */
883
884static PyObject *
885gl_rects(PyObject *self, PyObject *args)
886{
[391]887 short arg1 ;
888 short arg2 ;
889 short arg3 ;
890 short arg4 ;
891 if (!getishortarg(args, 4, 0, &arg1))
892 return NULL;
893 if (!getishortarg(args, 4, 1, &arg2))
894 return NULL;
895 if (!getishortarg(args, 4, 2, &arg3))
896 return NULL;
897 if (!getishortarg(args, 4, 3, &arg4))
898 return NULL;
899 rects( arg1 , arg2 , arg3 , arg4 );
900 Py_INCREF(Py_None);
901 return Py_None;
[2]902}
903
904/* void rmv2i long s long s */
905
906static PyObject *
907gl_rmv2i(PyObject *self, PyObject *args)
908{
[391]909 long arg1 ;
910 long arg2 ;
911 if (!getilongarg(args, 2, 0, &arg1))
912 return NULL;
913 if (!getilongarg(args, 2, 1, &arg2))
914 return NULL;
915 rmv2i( arg1 , arg2 );
916 Py_INCREF(Py_None);
917 return Py_None;
[2]918}
919
920/* void noport */
921
922static PyObject *
923gl_noport(PyObject *self, PyObject *args)
924{
[391]925 noport( );
926 Py_INCREF(Py_None);
927 return Py_None;
[2]928}
929
930/* void popviewport */
931
932static PyObject *
933gl_popviewport(PyObject *self, PyObject *args)
934{
[391]935 popviewport( );
936 Py_INCREF(Py_None);
937 return Py_None;
[2]938}
939
940/* void clearhitcode */
941
942static PyObject *
943gl_clearhitcode(PyObject *self, PyObject *args)
944{
[391]945 clearhitcode( );
946 Py_INCREF(Py_None);
947 return Py_None;
[2]948}
949
950/* void closeobj */
951
952static PyObject *
953gl_closeobj(PyObject *self, PyObject *args)
954{
[391]955 closeobj( );
956 Py_INCREF(Py_None);
957 return Py_None;
[2]958}
959
960/* void cursoff */
961
962static PyObject *
963gl_cursoff(PyObject *self, PyObject *args)
964{
[391]965 cursoff( );
966 Py_INCREF(Py_None);
967 return Py_None;
[2]968}
969
970/* void curson */
971
972static PyObject *
973gl_curson(PyObject *self, PyObject *args)
974{
[391]975 curson( );
976 Py_INCREF(Py_None);
977 return Py_None;
[2]978}
979
980/* void doublebuffer */
981
982static PyObject *
983gl_doublebuffer(PyObject *self, PyObject *args)
984{
[391]985 doublebuffer( );
986 Py_INCREF(Py_None);
987 return Py_None;
[2]988}
989
990/* void finish */
991
992static PyObject *
993gl_finish(PyObject *self, PyObject *args)
994{
[391]995 finish( );
996 Py_INCREF(Py_None);
997 return Py_None;
[2]998}
999
1000/* void gconfig */
1001
1002static PyObject *
1003gl_gconfig(PyObject *self, PyObject *args)
1004{
[391]1005 gconfig( );
1006 Py_INCREF(Py_None);
1007 return Py_None;
[2]1008}
1009
1010/* void ginit */
1011
1012static PyObject *
1013gl_ginit(PyObject *self, PyObject *args)
1014{
[391]1015 ginit( );
1016 Py_INCREF(Py_None);
1017 return Py_None;
[2]1018}
1019
1020/* void greset */
1021
1022static PyObject *
1023gl_greset(PyObject *self, PyObject *args)
1024{
[391]1025 greset( );
1026 Py_INCREF(Py_None);
1027 return Py_None;
[2]1028}
1029
1030/* void multimap */
1031
1032static PyObject *
1033gl_multimap(PyObject *self, PyObject *args)
1034{
[391]1035 multimap( );
1036 Py_INCREF(Py_None);
1037 return Py_None;
[2]1038}
1039
1040/* void onemap */
1041
1042static PyObject *
1043gl_onemap(PyObject *self, PyObject *args)
1044{
[391]1045 onemap( );
1046 Py_INCREF(Py_None);
1047 return Py_None;
[2]1048}
1049
1050/* void popattributes */
1051
1052static PyObject *
1053gl_popattributes(PyObject *self, PyObject *args)
1054{
[391]1055 popattributes( );
1056 Py_INCREF(Py_None);
1057 return Py_None;
[2]1058}
1059
1060/* void popmatrix */
1061
1062static PyObject *
1063gl_popmatrix(PyObject *self, PyObject *args)
1064{
[391]1065 popmatrix( );
1066 Py_INCREF(Py_None);
1067 return Py_None;
[2]1068}
1069
1070/* void pushattributes */
1071
1072static PyObject *
1073gl_pushattributes(PyObject *self, PyObject *args)
1074{
[391]1075 pushattributes( );
1076 Py_INCREF(Py_None);
1077 return Py_None;
[2]1078}
1079
1080/* void pushmatrix */
1081
1082static PyObject *
1083gl_pushmatrix(PyObject *self, PyObject *args)
1084{
[391]1085 pushmatrix( );
1086 Py_INCREF(Py_None);
1087 return Py_None;
[2]1088}
1089
1090/* void pushviewport */
1091
1092static PyObject *
1093gl_pushviewport(PyObject *self, PyObject *args)
1094{
[391]1095 pushviewport( );
1096 Py_INCREF(Py_None);
1097 return Py_None;
[2]1098}
1099
1100/* void qreset */
1101
1102static PyObject *
1103gl_qreset(PyObject *self, PyObject *args)
1104{
[391]1105 qreset( );
1106 Py_INCREF(Py_None);
1107 return Py_None;
[2]1108}
1109
1110/* void RGBmode */
1111
1112static PyObject *
1113gl_RGBmode(PyObject *self, PyObject *args)
1114{
[391]1115 RGBmode( );
1116 Py_INCREF(Py_None);
1117 return Py_None;
[2]1118}
1119
1120/* void singlebuffer */
1121
1122static PyObject *
1123gl_singlebuffer(PyObject *self, PyObject *args)
1124{
[391]1125 singlebuffer( );
1126 Py_INCREF(Py_None);
1127 return Py_None;
[2]1128}
1129
1130/* void swapbuffers */
1131
1132static PyObject *
1133gl_swapbuffers(PyObject *self, PyObject *args)
1134{
[391]1135 swapbuffers( );
1136 Py_INCREF(Py_None);
1137 return Py_None;
[2]1138}
1139
1140/* void gsync */
1141
1142static PyObject *
1143gl_gsync(PyObject *self, PyObject *args)
1144{
[391]1145 gsync( );
1146 Py_INCREF(Py_None);
1147 return Py_None;
[2]1148}
1149
1150/* void gflush */
1151
1152static PyObject *
1153gl_gflush(PyObject *self, PyObject *args)
1154{
[391]1155 gflush( );
1156 Py_INCREF(Py_None);
1157 return Py_None;
[2]1158}
1159
1160/* void tpon */
1161
1162static PyObject *
1163gl_tpon(PyObject *self, PyObject *args)
1164{
[391]1165 tpon( );
1166 Py_INCREF(Py_None);
1167 return Py_None;
[2]1168}
1169
1170/* void tpoff */
1171
1172static PyObject *
1173gl_tpoff(PyObject *self, PyObject *args)
1174{
[391]1175 tpoff( );
1176 Py_INCREF(Py_None);
1177 return Py_None;
[2]1178}
1179
1180/* void clkon */
1181
1182static PyObject *
1183gl_clkon(PyObject *self, PyObject *args)
1184{
[391]1185 clkon( );
1186 Py_INCREF(Py_None);
1187 return Py_None;
[2]1188}
1189
1190/* void clkoff */
1191
1192static PyObject *
1193gl_clkoff(PyObject *self, PyObject *args)
1194{
[391]1195 clkoff( );
1196 Py_INCREF(Py_None);
1197 return Py_None;
[2]1198}
1199
1200/* void ringbell */
1201
1202static PyObject *
1203gl_ringbell(PyObject *self, PyObject *args)
1204{
[391]1205 ringbell( );
1206 Py_INCREF(Py_None);
1207 return Py_None;
[2]1208}
1209
1210/* void gbegin */
1211
1212static PyObject *
1213gl_gbegin(PyObject *self, PyObject *args)
1214{
[391]1215 gbegin( );
1216 Py_INCREF(Py_None);
1217 return Py_None;
[2]1218}
1219
1220/* void textinit */
1221
1222static PyObject *
1223gl_textinit(PyObject *self, PyObject *args)
1224{
[391]1225 textinit( );
1226 Py_INCREF(Py_None);
1227 return Py_None;
[2]1228}
1229
1230/* void initnames */
1231
1232static PyObject *
1233gl_initnames(PyObject *self, PyObject *args)
1234{
[391]1235 initnames( );
1236 Py_INCREF(Py_None);
1237 return Py_None;
[2]1238}
1239
1240/* void pclos */
1241
1242static PyObject *
1243gl_pclos(PyObject *self, PyObject *args)
1244{
[391]1245 pclos( );
1246 Py_INCREF(Py_None);
1247 return Py_None;
[2]1248}
1249
1250/* void popname */
1251
1252static PyObject *
1253gl_popname(PyObject *self, PyObject *args)
1254{
[391]1255 popname( );
1256 Py_INCREF(Py_None);
1257 return Py_None;
[2]1258}
1259
1260/* void spclos */
1261
1262static PyObject *
1263gl_spclos(PyObject *self, PyObject *args)
1264{
[391]1265 spclos( );
1266 Py_INCREF(Py_None);
1267 return Py_None;
[2]1268}
1269
1270/* void zclear */
1271
1272static PyObject *
1273gl_zclear(PyObject *self, PyObject *args)
1274{
[391]1275 zclear( );
1276 Py_INCREF(Py_None);
1277 return Py_None;
[2]1278}
1279
1280/* void screenspace */
1281
1282static PyObject *
1283gl_screenspace(PyObject *self, PyObject *args)
1284{
[391]1285 screenspace( );
1286 Py_INCREF(Py_None);
1287 return Py_None;
[2]1288}
1289
1290/* void reshapeviewport */
1291
1292static PyObject *
1293gl_reshapeviewport(PyObject *self, PyObject *args)
1294{
[391]1295 reshapeviewport( );
1296 Py_INCREF(Py_None);
1297 return Py_None;
[2]1298}
1299
1300/* void winpush */
1301
1302static PyObject *
1303gl_winpush(PyObject *self, PyObject *args)
1304{
[391]1305 winpush( );
1306 Py_INCREF(Py_None);
1307 return Py_None;
[2]1308}
1309
1310/* void winpop */
1311
1312static PyObject *
1313gl_winpop(PyObject *self, PyObject *args)
1314{
[391]1315 winpop( );
1316 Py_INCREF(Py_None);
1317 return Py_None;
[2]1318}
1319
1320/* void foreground */
1321
1322static PyObject *
1323gl_foreground(PyObject *self, PyObject *args)
1324{
[391]1325 foreground( );
1326 Py_INCREF(Py_None);
1327 return Py_None;
[2]1328}
1329
1330/* void endfullscrn */
1331
1332static PyObject *
1333gl_endfullscrn(PyObject *self, PyObject *args)
1334{
[391]1335 endfullscrn( );
1336 Py_INCREF(Py_None);
1337 return Py_None;
[2]1338}
1339
1340/* void endpupmode */
1341
1342static PyObject *
1343gl_endpupmode(PyObject *self, PyObject *args)
1344{
[391]1345 endpupmode( );
1346 Py_INCREF(Py_None);
1347 return Py_None;
[2]1348}
1349
1350/* void fullscrn */
1351
1352static PyObject *
1353gl_fullscrn(PyObject *self, PyObject *args)
1354{
[391]1355 fullscrn( );
1356 Py_INCREF(Py_None);
1357 return Py_None;
[2]1358}
1359
1360/* void pupmode */
1361
1362static PyObject *
1363gl_pupmode(PyObject *self, PyObject *args)
1364{
[391]1365 pupmode( );
1366 Py_INCREF(Py_None);
1367 return Py_None;
[2]1368}
1369
1370/* void winconstraints */
1371
1372static PyObject *
1373gl_winconstraints(PyObject *self, PyObject *args)
1374{
[391]1375 winconstraints( );
1376 Py_INCREF(Py_None);
1377 return Py_None;
[2]1378}
1379
1380/* void pagecolor short s */
1381
1382static PyObject *
1383gl_pagecolor(PyObject *self, PyObject *args)
1384{
[391]1385 short arg1 ;
1386 if (!getishortarg(args, 1, 0, &arg1))
1387 return NULL;
1388 pagecolor( arg1 );
1389 Py_INCREF(Py_None);
1390 return Py_None;
[2]1391}
1392
1393/* void textcolor short s */
1394
1395static PyObject *
1396gl_textcolor(PyObject *self, PyObject *args)
1397{
[391]1398 short arg1 ;
1399 if (!getishortarg(args, 1, 0, &arg1))
1400 return NULL;
1401 textcolor( arg1 );
1402 Py_INCREF(Py_None);
1403 return Py_None;
[2]1404}
1405
1406/* void color short s */
1407
1408static PyObject *
1409gl_color(PyObject *self, PyObject *args)
1410{
[391]1411 short arg1 ;
1412 if (!getishortarg(args, 1, 0, &arg1))
1413 return NULL;
1414 color( arg1 );
1415 Py_INCREF(Py_None);
1416 return Py_None;
[2]1417}
1418
1419/* void curveit short s */
1420
1421static PyObject *
1422gl_curveit(PyObject *self, PyObject *args)
1423{
[391]1424 short arg1 ;
1425 if (!getishortarg(args, 1, 0, &arg1))
1426 return NULL;
1427 curveit( arg1 );
1428 Py_INCREF(Py_None);
1429 return Py_None;
[2]1430}
1431
1432/* void font short s */
1433
1434static PyObject *
1435gl_font(PyObject *self, PyObject *args)
1436{
[391]1437 short arg1 ;
1438 if (!getishortarg(args, 1, 0, &arg1))
1439 return NULL;
1440 font( arg1 );
1441 Py_INCREF(Py_None);
1442 return Py_None;
[2]1443}
1444
1445/* void linewidth short s */
1446
1447static PyObject *
1448gl_linewidth(PyObject *self, PyObject *args)
1449{
[391]1450 short arg1 ;
1451 if (!getishortarg(args, 1, 0, &arg1))
1452 return NULL;
1453 linewidth( arg1 );
1454 Py_INCREF(Py_None);
1455 return Py_None;
[2]1456}
1457
1458/* void setlinestyle short s */
1459
1460static PyObject *
1461gl_setlinestyle(PyObject *self, PyObject *args)
1462{
[391]1463 short arg1 ;
1464 if (!getishortarg(args, 1, 0, &arg1))
1465 return NULL;
1466 setlinestyle( arg1 );
1467 Py_INCREF(Py_None);
1468 return Py_None;
[2]1469}
1470
1471/* void setmap short s */
1472
1473static PyObject *
1474gl_setmap(PyObject *self, PyObject *args)
1475{
[391]1476 short arg1 ;
1477 if (!getishortarg(args, 1, 0, &arg1))
1478 return NULL;
1479 setmap( arg1 );
1480 Py_INCREF(Py_None);
1481 return Py_None;
[2]1482}
1483
1484/* void swapinterval short s */
1485
1486static PyObject *
1487gl_swapinterval(PyObject *self, PyObject *args)
1488{
[391]1489 short arg1 ;
1490 if (!getishortarg(args, 1, 0, &arg1))
1491 return NULL;
1492 swapinterval( arg1 );
1493 Py_INCREF(Py_None);
1494 return Py_None;
[2]1495}
1496
1497/* void writemask short s */
1498
1499static PyObject *
1500gl_writemask(PyObject *self, PyObject *args)
1501{
[391]1502 short arg1 ;
1503 if (!getishortarg(args, 1, 0, &arg1))
1504 return NULL;
1505 writemask( arg1 );
1506 Py_INCREF(Py_None);
1507 return Py_None;
[2]1508}
1509
1510/* void textwritemask short s */
1511
1512static PyObject *
1513gl_textwritemask(PyObject *self, PyObject *args)
1514{
[391]1515 short arg1 ;
1516 if (!getishortarg(args, 1, 0, &arg1))
1517 return NULL;
1518 textwritemask( arg1 );
1519 Py_INCREF(Py_None);
1520 return Py_None;
[2]1521}
1522
1523/* void qdevice short s */
1524
1525static PyObject *
1526gl_qdevice(PyObject *self, PyObject *args)
1527{
[391]1528 short arg1 ;
1529 if (!getishortarg(args, 1, 0, &arg1))
1530 return NULL;
1531 qdevice( arg1 );
1532 Py_INCREF(Py_None);
1533 return Py_None;
[2]1534}
1535
1536/* void unqdevice short s */
1537
1538static PyObject *
1539gl_unqdevice(PyObject *self, PyObject *args)
1540{
[391]1541 short arg1 ;
1542 if (!getishortarg(args, 1, 0, &arg1))
1543 return NULL;
1544 unqdevice( arg1 );
1545 Py_INCREF(Py_None);
1546 return Py_None;
[2]1547}
1548
1549/* void curvebasis short s */
1550
1551static PyObject *
1552gl_curvebasis(PyObject *self, PyObject *args)
1553{
[391]1554 short arg1 ;
1555 if (!getishortarg(args, 1, 0, &arg1))
1556 return NULL;
1557 curvebasis( arg1 );
1558 Py_INCREF(Py_None);
1559 return Py_None;
[2]1560}
1561
1562/* void curveprecision short s */
1563
1564static PyObject *
1565gl_curveprecision(PyObject *self, PyObject *args)
1566{
[391]1567 short arg1 ;
1568 if (!getishortarg(args, 1, 0, &arg1))
1569 return NULL;
1570 curveprecision( arg1 );
1571 Py_INCREF(Py_None);
1572 return Py_None;
[2]1573}
1574
1575/* void loadname short s */
1576
1577static PyObject *
1578gl_loadname(PyObject *self, PyObject *args)
1579{
[391]1580 short arg1 ;
1581 if (!getishortarg(args, 1, 0, &arg1))
1582 return NULL;
1583 loadname( arg1 );
1584 Py_INCREF(Py_None);
1585 return Py_None;
[2]1586}
1587
1588/* void passthrough short s */
1589
1590static PyObject *
1591gl_passthrough(PyObject *self, PyObject *args)
1592{
[391]1593 short arg1 ;
1594 if (!getishortarg(args, 1, 0, &arg1))
1595 return NULL;
1596 passthrough( arg1 );
1597 Py_INCREF(Py_None);
1598 return Py_None;
[2]1599}
1600
1601/* void pushname short s */
1602
1603static PyObject *
1604gl_pushname(PyObject *self, PyObject *args)
1605{
[391]1606 short arg1 ;
1607 if (!getishortarg(args, 1, 0, &arg1))
1608 return NULL;
1609 pushname( arg1 );
1610 Py_INCREF(Py_None);
1611 return Py_None;
[2]1612}
1613
1614/* void setmonitor short s */
1615
1616static PyObject *
1617gl_setmonitor(PyObject *self, PyObject *args)
1618{
[391]1619 short arg1 ;
1620 if (!getishortarg(args, 1, 0, &arg1))
1621 return NULL;
1622 setmonitor( arg1 );
1623 Py_INCREF(Py_None);
1624 return Py_None;
[2]1625}
1626
1627/* void setshade short s */
1628
1629static PyObject *
1630gl_setshade(PyObject *self, PyObject *args)
1631{
[391]1632 short arg1 ;
1633 if (!getishortarg(args, 1, 0, &arg1))
1634 return NULL;
1635 setshade( arg1 );
1636 Py_INCREF(Py_None);
1637 return Py_None;
[2]1638}
1639
1640/* void setpattern short s */
1641
1642static PyObject *
1643gl_setpattern(PyObject *self, PyObject *args)
1644{
[391]1645 short arg1 ;
1646 if (!getishortarg(args, 1, 0, &arg1))
1647 return NULL;
1648 setpattern( arg1 );
1649 Py_INCREF(Py_None);
1650 return Py_None;
[2]1651}
1652
1653/* void pagewritemask short s */
1654
1655static PyObject *
1656gl_pagewritemask(PyObject *self, PyObject *args)
1657{
[391]1658 short arg1 ;
1659 if (!getishortarg(args, 1, 0, &arg1))
1660 return NULL;
1661 pagewritemask( arg1 );
1662 Py_INCREF(Py_None);
1663 return Py_None;
[2]1664}
1665
1666/* void callobj long s */
1667
1668static PyObject *
1669gl_callobj(PyObject *self, PyObject *args)
1670{
[391]1671 long arg1 ;
1672 if (!getilongarg(args, 1, 0, &arg1))
1673 return NULL;
1674 callobj( arg1 );
1675 Py_INCREF(Py_None);
1676 return Py_None;
[2]1677}
1678
1679/* void delobj long s */
1680
1681static PyObject *
1682gl_delobj(PyObject *self, PyObject *args)
1683{
[391]1684 long arg1 ;
1685 if (!getilongarg(args, 1, 0, &arg1))
1686 return NULL;
1687 delobj( arg1 );
1688 Py_INCREF(Py_None);
1689 return Py_None;
[2]1690}
1691
1692/* void editobj long s */
1693
1694static PyObject *
1695gl_editobj(PyObject *self, PyObject *args)
1696{
[391]1697 long arg1 ;
1698 if (!getilongarg(args, 1, 0, &arg1))
1699 return NULL;
1700 editobj( arg1 );
1701 Py_INCREF(Py_None);
1702 return Py_None;
[2]1703}
1704
1705/* void makeobj long s */
1706
1707static PyObject *
1708gl_makeobj(PyObject *self, PyObject *args)
1709{
[391]1710 long arg1 ;
1711 if (!getilongarg(args, 1, 0, &arg1))
1712 return NULL;
1713 makeobj( arg1 );
1714 Py_INCREF(Py_None);
1715 return Py_None;
[2]1716}
1717
1718/* void maketag long s */
1719
1720static PyObject *
1721gl_maketag(PyObject *self, PyObject *args)
1722{
[391]1723 long arg1 ;
1724 if (!getilongarg(args, 1, 0, &arg1))
1725 return NULL;
1726 maketag( arg1 );
1727 Py_INCREF(Py_None);
1728 return Py_None;
[2]1729}
1730
1731/* void chunksize long s */
1732
1733static PyObject *
1734gl_chunksize(PyObject *self, PyObject *args)
1735{
[391]1736 long arg1 ;
1737 if (!getilongarg(args, 1, 0, &arg1))
1738 return NULL;
1739 chunksize( arg1 );
1740 Py_INCREF(Py_None);
1741 return Py_None;
[2]1742}
1743
1744/* void compactify long s */
1745
1746static PyObject *
1747gl_compactify(PyObject *self, PyObject *args)
1748{
[391]1749 long arg1 ;
1750 if (!getilongarg(args, 1, 0, &arg1))
1751 return NULL;
1752 compactify( arg1 );
1753 Py_INCREF(Py_None);
1754 return Py_None;
[2]1755}
1756
1757/* void deltag long s */
1758
1759static PyObject *
1760gl_deltag(PyObject *self, PyObject *args)
1761{
[391]1762 long arg1 ;
1763 if (!getilongarg(args, 1, 0, &arg1))
1764 return NULL;
1765 deltag( arg1 );
1766 Py_INCREF(Py_None);
1767 return Py_None;
[2]1768}
1769
1770/* void lsrepeat long s */
1771
1772static PyObject *
1773gl_lsrepeat(PyObject *self, PyObject *args)
1774{
[391]1775 long arg1 ;
1776 if (!getilongarg(args, 1, 0, &arg1))
1777 return NULL;
1778 lsrepeat( arg1 );
1779 Py_INCREF(Py_None);
1780 return Py_None;
[2]1781}
1782
1783/* void objinsert long s */
1784
1785static PyObject *
1786gl_objinsert(PyObject *self, PyObject *args)
1787{
[391]1788 long arg1 ;
1789 if (!getilongarg(args, 1, 0, &arg1))
1790 return NULL;
1791 objinsert( arg1 );
1792 Py_INCREF(Py_None);
1793 return Py_None;
[2]1794}
1795
1796/* void objreplace long s */
1797
1798static PyObject *
1799gl_objreplace(PyObject *self, PyObject *args)
1800{
[391]1801 long arg1 ;
1802 if (!getilongarg(args, 1, 0, &arg1))
1803 return NULL;
1804 objreplace( arg1 );
1805 Py_INCREF(Py_None);
1806 return Py_None;
[2]1807}
1808
1809/* void winclose long s */
1810
1811static PyObject *
1812gl_winclose(PyObject *self, PyObject *args)
1813{
[391]1814 long arg1 ;
1815 if (!getilongarg(args, 1, 0, &arg1))
1816 return NULL;
1817 winclose( arg1 );
1818 Py_INCREF(Py_None);
1819 return Py_None;
[2]1820}
1821
1822/* void blanktime long s */
1823
1824static PyObject *
1825gl_blanktime(PyObject *self, PyObject *args)
1826{
[391]1827 long arg1 ;
1828 if (!getilongarg(args, 1, 0, &arg1))
1829 return NULL;
1830 blanktime( arg1 );
1831 Py_INCREF(Py_None);
1832 return Py_None;
[2]1833}
1834
1835/* void freepup long s */
1836
1837static PyObject *
1838gl_freepup(PyObject *self, PyObject *args)
1839{
[391]1840 long arg1 ;
1841 if (!getilongarg(args, 1, 0, &arg1))
1842 return NULL;
1843 freepup( arg1 );
1844 Py_INCREF(Py_None);
1845 return Py_None;
[2]1846}
1847
1848/* void backbuffer long s */
1849
1850static PyObject *
1851gl_backbuffer(PyObject *self, PyObject *args)
1852{
[391]1853 long arg1 ;
1854 if (!getilongarg(args, 1, 0, &arg1))
1855 return NULL;
1856 backbuffer( arg1 );
1857 Py_INCREF(Py_None);
1858 return Py_None;
[2]1859}
1860
1861/* void frontbuffer long s */
1862
1863static PyObject *
1864gl_frontbuffer(PyObject *self, PyObject *args)
1865{
[391]1866 long arg1 ;
1867 if (!getilongarg(args, 1, 0, &arg1))
1868 return NULL;
1869 frontbuffer( arg1 );
1870 Py_INCREF(Py_None);
1871 return Py_None;
[2]1872}
1873
1874/* void lsbackup long s */
1875
1876static PyObject *
1877gl_lsbackup(PyObject *self, PyObject *args)
1878{
[391]1879 long arg1 ;
1880 if (!getilongarg(args, 1, 0, &arg1))
1881 return NULL;
1882 lsbackup( arg1 );
1883 Py_INCREF(Py_None);
1884 return Py_None;
[2]1885}
1886
1887/* void resetls long s */
1888
1889static PyObject *
1890gl_resetls(PyObject *self, PyObject *args)
1891{
[391]1892 long arg1 ;
1893 if (!getilongarg(args, 1, 0, &arg1))
1894 return NULL;
1895 resetls( arg1 );
1896 Py_INCREF(Py_None);
1897 return Py_None;
[2]1898}
1899
1900/* void lampon long s */
1901
1902static PyObject *
1903gl_lampon(PyObject *self, PyObject *args)
1904{
[391]1905 long arg1 ;
1906 if (!getilongarg(args, 1, 0, &arg1))
1907 return NULL;
1908 lampon( arg1 );
1909 Py_INCREF(Py_None);
1910 return Py_None;
[2]1911}
1912
1913/* void lampoff long s */
1914
1915static PyObject *
1916gl_lampoff(PyObject *self, PyObject *args)
1917{
[391]1918 long arg1 ;
1919 if (!getilongarg(args, 1, 0, &arg1))
1920 return NULL;
1921 lampoff( arg1 );
1922 Py_INCREF(Py_None);
1923 return Py_None;
[2]1924}
1925
1926/* void setbell long s */
1927
1928static PyObject *
1929gl_setbell(PyObject *self, PyObject *args)
1930{
[391]1931 long arg1 ;
1932 if (!getilongarg(args, 1, 0, &arg1))
1933 return NULL;
1934 setbell( arg1 );
1935 Py_INCREF(Py_None);
1936 return Py_None;
[2]1937}
1938
1939/* void blankscreen long s */
1940
1941static PyObject *
1942gl_blankscreen(PyObject *self, PyObject *args)
1943{
[391]1944 long arg1 ;
1945 if (!getilongarg(args, 1, 0, &arg1))
1946 return NULL;
1947 blankscreen( arg1 );
1948 Py_INCREF(Py_None);
1949 return Py_None;
[2]1950}
1951
1952/* void depthcue long s */
1953
1954static PyObject *
1955gl_depthcue(PyObject *self, PyObject *args)
1956{
[391]1957 long arg1 ;
1958 if (!getilongarg(args, 1, 0, &arg1))
1959 return NULL;
1960 depthcue( arg1 );
1961 Py_INCREF(Py_None);
1962 return Py_None;
[2]1963}
1964
1965/* void zbuffer long s */
1966
1967static PyObject *
1968gl_zbuffer(PyObject *self, PyObject *args)
1969{
[391]1970 long arg1 ;
1971 if (!getilongarg(args, 1, 0, &arg1))
1972 return NULL;
1973 zbuffer( arg1 );
1974 Py_INCREF(Py_None);
1975 return Py_None;
[2]1976}
1977
1978/* void backface long s */
1979
1980static PyObject *
1981gl_backface(PyObject *self, PyObject *args)
1982{
[391]1983 long arg1 ;
1984 if (!getilongarg(args, 1, 0, &arg1))
1985 return NULL;
1986 backface( arg1 );
1987 Py_INCREF(Py_None);
1988 return Py_None;
[2]1989}
1990
1991/* void cmov2i long s long s */
1992
1993static PyObject *
1994gl_cmov2i(PyObject *self, PyObject *args)
1995{
[391]1996 long arg1 ;
1997 long arg2 ;
1998 if (!getilongarg(args, 2, 0, &arg1))
1999 return NULL;
2000 if (!getilongarg(args, 2, 1, &arg2))
2001 return NULL;
2002 cmov2i( arg1 , arg2 );
2003 Py_INCREF(Py_None);
2004 return Py_None;
[2]2005}
2006
2007/* void draw2i long s long s */
2008
2009static PyObject *
2010gl_draw2i(PyObject *self, PyObject *args)
2011{
[391]2012 long arg1 ;
2013 long arg2 ;
2014 if (!getilongarg(args, 2, 0, &arg1))
2015 return NULL;
2016 if (!getilongarg(args, 2, 1, &arg2))
2017 return NULL;
2018 draw2i( arg1 , arg2 );
2019 Py_INCREF(Py_None);
2020 return Py_None;
[2]2021}
2022
2023/* void move2i long s long s */
2024
2025static PyObject *
2026gl_move2i(PyObject *self, PyObject *args)
2027{
[391]2028 long arg1 ;
2029 long arg2 ;
2030 if (!getilongarg(args, 2, 0, &arg1))
2031 return NULL;
2032 if (!getilongarg(args, 2, 1, &arg2))
2033 return NULL;
2034 move2i( arg1 , arg2 );
2035 Py_INCREF(Py_None);
2036 return Py_None;
[2]2037}
2038
2039/* void pnt2i long s long s */
2040
2041static PyObject *
2042gl_pnt2i(PyObject *self, PyObject *args)
2043{
[391]2044 long arg1 ;
2045 long arg2 ;
2046 if (!getilongarg(args, 2, 0, &arg1))
2047 return NULL;
2048 if (!getilongarg(args, 2, 1, &arg2))
2049 return NULL;
2050 pnt2i( arg1 , arg2 );
2051 Py_INCREF(Py_None);
2052 return Py_None;
[2]2053}
2054
2055/* void patchbasis long s long s */
2056
2057static PyObject *
2058gl_patchbasis(PyObject *self, PyObject *args)
2059{
[391]2060 long arg1 ;
2061 long arg2 ;
2062 if (!getilongarg(args, 2, 0, &arg1))
2063 return NULL;
2064 if (!getilongarg(args, 2, 1, &arg2))
2065 return NULL;
2066 patchbasis( arg1 , arg2 );
2067 Py_INCREF(Py_None);
2068 return Py_None;
[2]2069}
2070
2071/* void patchprecision long s long s */
2072
2073static PyObject *
2074gl_patchprecision(PyObject *self, PyObject *args)
2075{
[391]2076 long arg1 ;
2077 long arg2 ;
2078 if (!getilongarg(args, 2, 0, &arg1))
2079 return NULL;
2080 if (!getilongarg(args, 2, 1, &arg2))
2081 return NULL;
2082 patchprecision( arg1 , arg2 );
2083 Py_INCREF(Py_None);
2084 return Py_None;
[2]2085}
2086
2087/* void pdr2i long s long s */
2088
2089static PyObject *
2090gl_pdr2i(PyObject *self, PyObject *args)
2091{
[391]2092 long arg1 ;
2093 long arg2 ;
2094 if (!getilongarg(args, 2, 0, &arg1))
2095 return NULL;
2096 if (!getilongarg(args, 2, 1, &arg2))
2097 return NULL;
2098 pdr2i( arg1 , arg2 );
2099 Py_INCREF(Py_None);
2100 return Py_None;
[2]2101}
2102
2103/* void pmv2i long s long s */
2104
2105static PyObject *
2106gl_pmv2i(PyObject *self, PyObject *args)
2107{
[391]2108 long arg1 ;
2109 long arg2 ;
2110 if (!getilongarg(args, 2, 0, &arg1))
2111 return NULL;
2112 if (!getilongarg(args, 2, 1, &arg2))
2113 return NULL;
2114 pmv2i( arg1 , arg2 );
2115 Py_INCREF(Py_None);
2116 return Py_None;
[2]2117}
2118
2119/* void rpdr2i long s long s */
2120
2121static PyObject *
2122gl_rpdr2i(PyObject *self, PyObject *args)
2123{
[391]2124 long arg1 ;
2125 long arg2 ;
2126 if (!getilongarg(args, 2, 0, &arg1))
2127 return NULL;
2128 if (!getilongarg(args, 2, 1, &arg2))
2129 return NULL;
2130 rpdr2i( arg1 , arg2 );
2131 Py_INCREF(Py_None);
2132 return Py_None;
[2]2133}
2134
2135/* void rpmv2i long s long s */
2136
2137static PyObject *
2138gl_rpmv2i(PyObject *self, PyObject *args)
2139{
[391]2140 long arg1 ;
2141 long arg2 ;
2142 if (!getilongarg(args, 2, 0, &arg1))
2143 return NULL;
2144 if (!getilongarg(args, 2, 1, &arg2))
2145 return NULL;
2146 rpmv2i( arg1 , arg2 );
2147 Py_INCREF(Py_None);
2148 return Py_None;
[2]2149}
2150
2151/* void xfpt2i long s long s */
2152
2153static PyObject *
2154gl_xfpt2i(PyObject *self, PyObject *args)
2155{
[391]2156 long arg1 ;
2157 long arg2 ;
2158 if (!getilongarg(args, 2, 0, &arg1))
2159 return NULL;
2160 if (!getilongarg(args, 2, 1, &arg2))
2161 return NULL;
2162 xfpt2i( arg1 , arg2 );
2163 Py_INCREF(Py_None);
2164 return Py_None;
[2]2165}
2166
2167/* void objdelete long s long s */
2168
2169static PyObject *
2170gl_objdelete(PyObject *self, PyObject *args)
2171{
[391]2172 long arg1 ;
2173 long arg2 ;
2174 if (!getilongarg(args, 2, 0, &arg1))
2175 return NULL;
2176 if (!getilongarg(args, 2, 1, &arg2))
2177 return NULL;
2178 objdelete( arg1 , arg2 );
2179 Py_INCREF(Py_None);
2180 return Py_None;
[2]2181}
2182
2183/* void patchcurves long s long s */
2184
2185static PyObject *
2186gl_patchcurves(PyObject *self, PyObject *args)
2187{
[391]2188 long arg1 ;
2189 long arg2 ;
2190 if (!getilongarg(args, 2, 0, &arg1))
2191 return NULL;
2192 if (!getilongarg(args, 2, 1, &arg2))
2193 return NULL;
2194 patchcurves( arg1 , arg2 );
2195 Py_INCREF(Py_None);
2196 return Py_None;
[2]2197}
2198
2199/* void minsize long s long s */
2200
2201static PyObject *
2202gl_minsize(PyObject *self, PyObject *args)
2203{
[391]2204 long arg1 ;
2205 long arg2 ;
2206 if (!getilongarg(args, 2, 0, &arg1))
2207 return NULL;
2208 if (!getilongarg(args, 2, 1, &arg2))
2209 return NULL;
2210 minsize( arg1 , arg2 );
2211 Py_INCREF(Py_None);
2212 return Py_None;
[2]2213}
2214
2215/* void maxsize long s long s */
2216
2217static PyObject *
2218gl_maxsize(PyObject *self, PyObject *args)
2219{
[391]2220 long arg1 ;
2221 long arg2 ;
2222 if (!getilongarg(args, 2, 0, &arg1))
2223 return NULL;
2224 if (!getilongarg(args, 2, 1, &arg2))
2225 return NULL;
2226 maxsize( arg1 , arg2 );
2227 Py_INCREF(Py_None);
2228 return Py_None;
[2]2229}
2230
2231/* void keepaspect long s long s */
2232
2233static PyObject *
2234gl_keepaspect(PyObject *self, PyObject *args)
2235{
[391]2236 long arg1 ;
2237 long arg2 ;
2238 if (!getilongarg(args, 2, 0, &arg1))
2239 return NULL;
2240 if (!getilongarg(args, 2, 1, &arg2))
2241 return NULL;
2242 keepaspect( arg1 , arg2 );
2243 Py_INCREF(Py_None);
2244 return Py_None;
[2]2245}
2246
2247/* void prefsize long s long s */
2248
2249static PyObject *
2250gl_prefsize(PyObject *self, PyObject *args)
2251{
[391]2252 long arg1 ;
2253 long arg2 ;
2254 if (!getilongarg(args, 2, 0, &arg1))
2255 return NULL;
2256 if (!getilongarg(args, 2, 1, &arg2))
2257 return NULL;
2258 prefsize( arg1 , arg2 );
2259 Py_INCREF(Py_None);
2260 return Py_None;
[2]2261}
2262
2263/* void stepunit long s long s */
2264
2265static PyObject *
2266gl_stepunit(PyObject *self, PyObject *args)
2267{
[391]2268 long arg1 ;
2269 long arg2 ;
2270 if (!getilongarg(args, 2, 0, &arg1))
2271 return NULL;
2272 if (!getilongarg(args, 2, 1, &arg2))
2273 return NULL;
2274 stepunit( arg1 , arg2 );
2275 Py_INCREF(Py_None);
2276 return Py_None;
[2]2277}
2278
2279/* void fudge long s long s */
2280
2281static PyObject *
2282gl_fudge(PyObject *self, PyObject *args)
2283{
[391]2284 long arg1 ;
2285 long arg2 ;
2286 if (!getilongarg(args, 2, 0, &arg1))
2287 return NULL;
2288 if (!getilongarg(args, 2, 1, &arg2))
2289 return NULL;
2290 fudge( arg1 , arg2 );
2291 Py_INCREF(Py_None);
2292 return Py_None;
[2]2293}
2294
2295/* void winmove long s long s */
2296
2297static PyObject *
2298gl_winmove(PyObject *self, PyObject *args)
2299{
[391]2300 long arg1 ;
2301 long arg2 ;
2302 if (!getilongarg(args, 2, 0, &arg1))
2303 return NULL;
2304 if (!getilongarg(args, 2, 1, &arg2))
2305 return NULL;
2306 winmove( arg1 , arg2 );
2307 Py_INCREF(Py_None);
2308 return Py_None;
[2]2309}
2310
2311/* void attachcursor short s short s */
2312
2313static PyObject *
2314gl_attachcursor(PyObject *self, PyObject *args)
2315{
[391]2316 short arg1 ;
2317 short arg2 ;
2318 if (!getishortarg(args, 2, 0, &arg1))
2319 return NULL;
2320 if (!getishortarg(args, 2, 1, &arg2))
2321 return NULL;
2322 attachcursor( arg1 , arg2 );
2323 Py_INCREF(Py_None);
2324 return Py_None;
[2]2325}
2326
2327/* void deflinestyle short s short s */
2328
2329static PyObject *
2330gl_deflinestyle(PyObject *self, PyObject *args)
2331{
[391]2332 short arg1 ;
2333 short arg2 ;
2334 if (!getishortarg(args, 2, 0, &arg1))
2335 return NULL;
2336 if (!getishortarg(args, 2, 1, &arg2))
2337 return NULL;
2338 deflinestyle( arg1 , arg2 );
2339 Py_INCREF(Py_None);
2340 return Py_None;
[2]2341}
2342
2343/* void noise short s short s */
2344
2345static PyObject *
2346gl_noise(PyObject *self, PyObject *args)
2347{
[391]2348 short arg1 ;
2349 short arg2 ;
2350 if (!getishortarg(args, 2, 0, &arg1))
2351 return NULL;
2352 if (!getishortarg(args, 2, 1, &arg2))
2353 return NULL;
2354 noise( arg1 , arg2 );
2355 Py_INCREF(Py_None);
2356 return Py_None;
[2]2357}
2358
2359/* void picksize short s short s */
2360
2361static PyObject *
2362gl_picksize(PyObject *self, PyObject *args)
2363{
[391]2364 short arg1 ;
2365 short arg2 ;
2366 if (!getishortarg(args, 2, 0, &arg1))
2367 return NULL;
2368 if (!getishortarg(args, 2, 1, &arg2))
2369 return NULL;
2370 picksize( arg1 , arg2 );
2371 Py_INCREF(Py_None);
2372 return Py_None;
[2]2373}
2374
2375/* void qenter short s short s */
2376
2377static PyObject *
2378gl_qenter(PyObject *self, PyObject *args)
2379{
[391]2380 short arg1 ;
2381 short arg2 ;
2382 if (!getishortarg(args, 2, 0, &arg1))
2383 return NULL;
2384 if (!getishortarg(args, 2, 1, &arg2))
2385 return NULL;
2386 qenter( arg1 , arg2 );
2387 Py_INCREF(Py_None);
2388 return Py_None;
[2]2389}
2390
2391/* void setdepth short s short s */
2392
2393static PyObject *
2394gl_setdepth(PyObject *self, PyObject *args)
2395{
[391]2396 short arg1 ;
2397 short arg2 ;
2398 if (!getishortarg(args, 2, 0, &arg1))
2399 return NULL;
2400 if (!getishortarg(args, 2, 1, &arg2))
2401 return NULL;
2402 setdepth( arg1 , arg2 );
2403 Py_INCREF(Py_None);
2404 return Py_None;
[2]2405}
2406
2407/* void cmov2s short s short s */
2408
2409static PyObject *
2410gl_cmov2s(PyObject *self, PyObject *args)
2411{
[391]2412 short arg1 ;
2413 short arg2 ;
2414 if (!getishortarg(args, 2, 0, &arg1))
2415 return NULL;
2416 if (!getishortarg(args, 2, 1, &arg2))
2417 return NULL;
2418 cmov2s( arg1 , arg2 );
2419 Py_INCREF(Py_None);
2420 return Py_None;
[2]2421}
2422
2423/* void draw2s short s short s */
2424
2425static PyObject *
2426gl_draw2s(PyObject *self, PyObject *args)
2427{
[391]2428 short arg1 ;
2429 short arg2 ;
2430 if (!getishortarg(args, 2, 0, &arg1))
2431 return NULL;
2432 if (!getishortarg(args, 2, 1, &arg2))
2433 return NULL;
2434 draw2s( arg1 , arg2 );
2435 Py_INCREF(Py_None);
2436 return Py_None;
[2]2437}
2438
2439/* void move2s short s short s */
2440
2441static PyObject *
2442gl_move2s(PyObject *self, PyObject *args)
2443{
[391]2444 short arg1 ;
2445 short arg2 ;
2446 if (!getishortarg(args, 2, 0, &arg1))
2447 return NULL;
2448 if (!getishortarg(args, 2, 1, &arg2))
2449 return NULL;
2450 move2s( arg1 , arg2 );
2451 Py_INCREF(Py_None);
2452 return Py_None;
[2]2453}
2454
2455/* void pdr2s short s short s */
2456
2457static PyObject *
2458gl_pdr2s(PyObject *self, PyObject *args)
2459{
[391]2460 short arg1 ;
2461 short arg2 ;
2462 if (!getishortarg(args, 2, 0, &arg1))
2463 return NULL;
2464 if (!getishortarg(args, 2, 1, &arg2))
2465 return NULL;
2466 pdr2s( arg1 , arg2 );
2467 Py_INCREF(Py_None);
2468 return Py_None;
[2]2469}
2470
2471/* void pmv2s short s short s */
2472
2473static PyObject *
2474gl_pmv2s(PyObject *self, PyObject *args)
2475{
[391]2476 short arg1 ;
2477 short arg2 ;
2478 if (!getishortarg(args, 2, 0, &arg1))
2479 return NULL;
2480 if (!getishortarg(args, 2, 1, &arg2))
2481 return NULL;
2482 pmv2s( arg1 , arg2 );
2483 Py_INCREF(Py_None);
2484 return Py_None;
[2]2485}
2486
2487/* void pnt2s short s short s */
2488
2489static PyObject *
2490gl_pnt2s(PyObject *self, PyObject *args)
2491{
[391]2492 short arg1 ;
2493 short arg2 ;
2494 if (!getishortarg(args, 2, 0, &arg1))
2495 return NULL;
2496 if (!getishortarg(args, 2, 1, &arg2))
2497 return NULL;
2498 pnt2s( arg1 , arg2 );
2499 Py_INCREF(Py_None);
2500 return Py_None;
[2]2501}
2502
2503/* void rdr2s short s short s */
2504
2505static PyObject *
2506gl_rdr2s(PyObject *self, PyObject *args)
2507{
[391]2508 short arg1 ;
2509 short arg2 ;
2510 if (!getishortarg(args, 2, 0, &arg1))
2511 return NULL;
2512 if (!getishortarg(args, 2, 1, &arg2))
2513 return NULL;
2514 rdr2s( arg1 , arg2 );
2515 Py_INCREF(Py_None);
2516 return Py_None;
[2]2517}
2518
2519/* void rmv2s short s short s */
2520
2521static PyObject *
2522gl_rmv2s(PyObject *self, PyObject *args)
2523{
[391]2524 short arg1 ;
2525 short arg2 ;
2526 if (!getishortarg(args, 2, 0, &arg1))
2527 return NULL;
2528 if (!getishortarg(args, 2, 1, &arg2))
2529 return NULL;
2530 rmv2s( arg1 , arg2 );
2531 Py_INCREF(Py_None);
2532 return Py_None;
[2]2533}
2534
2535/* void rpdr2s short s short s */
2536
2537static PyObject *
2538gl_rpdr2s(PyObject *self, PyObject *args)
2539{
[391]2540 short arg1 ;
2541 short arg2 ;
2542 if (!getishortarg(args, 2, 0, &arg1))
2543 return NULL;
2544 if (!getishortarg(args, 2, 1, &arg2))
2545 return NULL;
2546 rpdr2s( arg1 , arg2 );
2547 Py_INCREF(Py_None);
2548 return Py_None;
[2]2549}
2550
2551/* void rpmv2s short s short s */
2552
2553static PyObject *
2554gl_rpmv2s(PyObject *self, PyObject *args)
2555{
[391]2556 short arg1 ;
2557 short arg2 ;
2558 if (!getishortarg(args, 2, 0, &arg1))
2559 return NULL;
2560 if (!getishortarg(args, 2, 1, &arg2))
2561 return NULL;
2562 rpmv2s( arg1 , arg2 );
2563 Py_INCREF(Py_None);
2564 return Py_None;
[2]2565}
2566
2567/* void xfpt2s short s short s */
2568
2569static PyObject *
2570gl_xfpt2s(PyObject *self, PyObject *args)
2571{
[391]2572 short arg1 ;
2573 short arg2 ;
2574 if (!getishortarg(args, 2, 0, &arg1))
2575 return NULL;
2576 if (!getishortarg(args, 2, 1, &arg2))
2577 return NULL;
2578 xfpt2s( arg1 , arg2 );
2579 Py_INCREF(Py_None);
2580 return Py_None;
[2]2581}
2582
2583/* void cmov2 float s float s */
2584
2585static PyObject *
2586gl_cmov2(PyObject *self, PyObject *args)
2587{
[391]2588 float arg1 ;
2589 float arg2 ;
2590 if (!getifloatarg(args, 2, 0, &arg1))
2591 return NULL;
2592 if (!getifloatarg(args, 2, 1, &arg2))
2593 return NULL;
2594 cmov2( arg1 , arg2 );
2595 Py_INCREF(Py_None);
2596 return Py_None;
[2]2597}
2598
2599/* void draw2 float s float s */
2600
2601static PyObject *
2602gl_draw2(PyObject *self, PyObject *args)
2603{
[391]2604 float arg1 ;
2605 float arg2 ;
2606 if (!getifloatarg(args, 2, 0, &arg1))
2607 return NULL;
2608 if (!getifloatarg(args, 2, 1, &arg2))
2609 return NULL;
2610 draw2( arg1 , arg2 );
2611 Py_INCREF(Py_None);
2612 return Py_None;
[2]2613}
2614
2615/* void move2 float s float s */
2616
2617static PyObject *
2618gl_move2(PyObject *self, PyObject *args)
2619{
[391]2620 float arg1 ;
2621 float arg2 ;
2622 if (!getifloatarg(args, 2, 0, &arg1))
2623 return NULL;
2624 if (!getifloatarg(args, 2, 1, &arg2))
2625 return NULL;
2626 move2( arg1 , arg2 );
2627 Py_INCREF(Py_None);
2628 return Py_None;
[2]2629}
2630
2631/* void pnt2 float s float s */
2632
2633static PyObject *
2634gl_pnt2(PyObject *self, PyObject *args)
2635{
[391]2636 float arg1 ;
2637 float arg2 ;
2638 if (!getifloatarg(args, 2, 0, &arg1))
2639 return NULL;
2640 if (!getifloatarg(args, 2, 1, &arg2))
2641 return NULL;
2642 pnt2( arg1 , arg2 );
2643 Py_INCREF(Py_None);
2644 return Py_None;
[2]2645}
2646
2647/* void pdr2 float s float s */
2648
2649static PyObject *
2650gl_pdr2(PyObject *self, PyObject *args)
2651{
[391]2652 float arg1 ;
2653 float arg2 ;
2654 if (!getifloatarg(args, 2, 0, &arg1))
2655 return NULL;
2656 if (!getifloatarg(args, 2, 1, &arg2))
2657 return NULL;
2658 pdr2( arg1 , arg2 );
2659 Py_INCREF(Py_None);
2660 return Py_None;
[2]2661}
2662
2663/* void pmv2 float s float s */
2664
2665static PyObject *
2666gl_pmv2(PyObject *self, PyObject *args)
2667{
[391]2668 float arg1 ;
2669 float arg2 ;
2670 if (!getifloatarg(args, 2, 0, &arg1))
2671 return NULL;
2672 if (!getifloatarg(args, 2, 1, &arg2))
2673 return NULL;
2674 pmv2( arg1 , arg2 );
2675 Py_INCREF(Py_None);
2676 return Py_None;
[2]2677}
2678
2679/* void rdr2 float s float s */
2680
2681static PyObject *
2682gl_rdr2(PyObject *self, PyObject *args)
2683{
[391]2684 float arg1 ;
2685 float arg2 ;
2686 if (!getifloatarg(args, 2, 0, &arg1))
2687 return NULL;
2688 if (!getifloatarg(args, 2, 1, &arg2))
2689 return NULL;
2690 rdr2( arg1 , arg2 );
2691 Py_INCREF(Py_None);
2692 return Py_None;
[2]2693}
2694
2695/* void rmv2 float s float s */
2696
2697static PyObject *
2698gl_rmv2(PyObject *self, PyObject *args)
2699{
[391]2700 float arg1 ;
2701 float arg2 ;
2702 if (!getifloatarg(args, 2, 0, &arg1))
2703 return NULL;
2704 if (!getifloatarg(args, 2, 1, &arg2))
2705 return NULL;
2706 rmv2( arg1 , arg2 );
2707 Py_INCREF(Py_None);
2708 return Py_None;
[2]2709}
2710
2711/* void rpdr2 float s float s */
2712
2713static PyObject *
2714gl_rpdr2(PyObject *self, PyObject *args)
2715{
[391]2716 float arg1 ;
2717 float arg2 ;
2718 if (!getifloatarg(args, 2, 0, &arg1))
2719 return NULL;
2720 if (!getifloatarg(args, 2, 1, &arg2))
2721 return NULL;
2722 rpdr2( arg1 , arg2 );
2723 Py_INCREF(Py_None);
2724 return Py_None;
[2]2725}
2726
2727/* void rpmv2 float s float s */
2728
2729static PyObject *
2730gl_rpmv2(PyObject *self, PyObject *args)
2731{
[391]2732 float arg1 ;
2733 float arg2 ;
2734 if (!getifloatarg(args, 2, 0, &arg1))
2735 return NULL;
2736 if (!getifloatarg(args, 2, 1, &arg2))
2737 return NULL;
2738 rpmv2( arg1 , arg2 );
2739 Py_INCREF(Py_None);
2740 return Py_None;
[2]2741}
2742
2743/* void xfpt2 float s float s */
2744
2745static PyObject *
2746gl_xfpt2(PyObject *self, PyObject *args)
2747{
[391]2748 float arg1 ;
2749 float arg2 ;
2750 if (!getifloatarg(args, 2, 0, &arg1))
2751 return NULL;
2752 if (!getifloatarg(args, 2, 1, &arg2))
2753 return NULL;
2754 xfpt2( arg1 , arg2 );
2755 Py_INCREF(Py_None);
2756 return Py_None;
[2]2757}
2758
2759/* void loadmatrix float s[4*4] */
2760
2761static PyObject *
2762gl_loadmatrix(PyObject *self, PyObject *args)
2763{
[391]2764 float arg1 [ 4 ] [ 4 ] ;
2765 if (!getifloatarray(args, 1, 0, 4 * 4 , (float *) arg1))
2766 return NULL;
2767 loadmatrix( arg1 );
2768 Py_INCREF(Py_None);
2769 return Py_None;
[2]2770}
2771
2772/* void multmatrix float s[4*4] */
2773
2774static PyObject *
2775gl_multmatrix(PyObject *self, PyObject *args)
2776{
[391]2777 float arg1 [ 4 ] [ 4 ] ;
2778 if (!getifloatarray(args, 1, 0, 4 * 4 , (float *) arg1))
2779 return NULL;
2780 multmatrix( arg1 );
2781 Py_INCREF(Py_None);
2782 return Py_None;
[2]2783}
2784
2785/* void crv float s[3*4] */
2786
2787static PyObject *
2788gl_crv(PyObject *self, PyObject *args)
2789{
[391]2790 float arg1 [ 4 ] [ 3 ] ;
2791 if (!getifloatarray(args, 1, 0, 3 * 4 , (float *) arg1))
2792 return NULL;
2793 crv( arg1 );
2794 Py_INCREF(Py_None);
2795 return Py_None;
[2]2796}
2797
2798/* void rcrv float s[4*4] */
2799
2800static PyObject *
2801gl_rcrv(PyObject *self, PyObject *args)
2802{
[391]2803 float arg1 [ 4 ] [ 4 ] ;
2804 if (!getifloatarray(args, 1, 0, 4 * 4 , (float *) arg1))
2805 return NULL;
2806 rcrv( arg1 );
2807 Py_INCREF(Py_None);
2808 return Py_None;
[2]2809}
2810
2811/* void addtopup long s char *s long s */
2812
2813static PyObject *
2814gl_addtopup(PyObject *self, PyObject *args)
2815{
[391]2816 long arg1 ;
2817 string arg2 ;
2818 long arg3 ;
2819 if (!getilongarg(args, 3, 0, &arg1))
2820 return NULL;
2821 if (!getistringarg(args, 3, 1, &arg2))
2822 return NULL;
2823 if (!getilongarg(args, 3, 2, &arg3))
2824 return NULL;
2825 addtopup( arg1 , arg2 , arg3 );
2826 Py_INCREF(Py_None);
2827 return Py_None;
[2]2828}
2829
2830/* void charstr char *s */
2831
2832static PyObject *
2833gl_charstr(PyObject *self, PyObject *args)
2834{
[391]2835 string arg1 ;
2836 if (!getistringarg(args, 1, 0, &arg1))
2837 return NULL;
2838 charstr( arg1 );
2839 Py_INCREF(Py_None);
2840 return Py_None;
[2]2841}
2842
2843/* void getport char *s */
2844
2845static PyObject *
2846gl_getport(PyObject *self, PyObject *args)
2847{
[391]2848 string arg1 ;
2849 if (!getistringarg(args, 1, 0, &arg1))
2850 return NULL;
2851 getport( arg1 );
2852 Py_INCREF(Py_None);
2853 return Py_None;
[2]2854}
2855
2856/* long strwidth char *s */
2857
2858static PyObject *
2859gl_strwidth(PyObject *self, PyObject *args)
2860{
[391]2861 long retval;
2862 string arg1 ;
2863 if (!getistringarg(args, 1, 0, &arg1))
2864 return NULL;
2865 retval = strwidth( arg1 );
2866 return mknewlongobject(retval);
[2]2867}
2868
2869/* long winopen char *s */
2870
2871static PyObject *
2872gl_winopen(PyObject *self, PyObject *args)
2873{
[391]2874 long retval;
2875 string arg1 ;
2876 if (!getistringarg(args, 1, 0, &arg1))
2877 return NULL;
2878 retval = winopen( arg1 );
2879 return mknewlongobject(retval);
[2]2880}
2881
2882/* void wintitle char *s */
2883
2884static PyObject *
2885gl_wintitle(PyObject *self, PyObject *args)
2886{
[391]2887 string arg1 ;
2888 if (!getistringarg(args, 1, 0, &arg1))
2889 return NULL;
2890 wintitle( arg1 );
2891 Py_INCREF(Py_None);
2892 return Py_None;
[2]2893}
2894
2895/* void polf long s float s[3*arg1] */
2896
2897static PyObject *
2898gl_polf(PyObject *self, PyObject *args)
2899{
[391]2900 long arg1 ;
2901 float (* arg2) [ 3 ] ;
2902 if (!getilongarraysize(args, 1, 0, &arg1))
2903 return NULL;
2904 arg1 = arg1 / 3;
2905 if ((arg2 = (float(*)[3]) PyMem_NEW(float , 3 * arg1 )) == NULL)
2906 return PyErr_NoMemory();
2907 if (!getifloatarray(args, 1, 0, 3 * arg1 , (float *) arg2))
2908 return NULL;
2909 polf( arg1 , arg2 );
2910 PyMem_DEL(arg2);
2911 Py_INCREF(Py_None);
2912 return Py_None;
[2]2913}
2914
2915/* void polf2 long s float s[2*arg1] */
2916
2917static PyObject *
2918gl_polf2(PyObject *self, PyObject *args)
2919{
[391]2920 long arg1 ;
2921 float (* arg2) [ 2 ] ;
2922 if (!getilongarraysize(args, 1, 0, &arg1))
2923 return NULL;
2924 arg1 = arg1 / 2;
2925 if ((arg2 = (float(*)[2]) PyMem_NEW(float , 2 * arg1 )) == NULL)
2926 return PyErr_NoMemory();
2927 if (!getifloatarray(args, 1, 0, 2 * arg1 , (float *) arg2))
2928 return NULL;
2929 polf2( arg1 , arg2 );
2930 PyMem_DEL(arg2);
2931 Py_INCREF(Py_None);
2932 return Py_None;
[2]2933}
2934
2935/* void poly long s float s[3*arg1] */
2936
2937static PyObject *
2938gl_poly(PyObject *self, PyObject *args)
2939{
[391]2940 long arg1 ;
2941 float (* arg2) [ 3 ] ;
2942 if (!getilongarraysize(args, 1, 0, &arg1))
2943 return NULL;
2944 arg1 = arg1 / 3;
2945 if ((arg2 = (float(*)[3]) PyMem_NEW(float , 3 * arg1 )) == NULL)
2946 return PyErr_NoMemory();
2947 if (!getifloatarray(args, 1, 0, 3 * arg1 , (float *) arg2))
2948 return NULL;
2949 poly( arg1 , arg2 );
2950 PyMem_DEL(arg2);
2951 Py_INCREF(Py_None);
2952 return Py_None;
[2]2953}
2954
2955/* void poly2 long s float s[2*arg1] */
2956
2957static PyObject *
2958gl_poly2(PyObject *self, PyObject *args)
2959{
[391]2960 long arg1 ;
2961 float (* arg2) [ 2 ] ;
2962 if (!getilongarraysize(args, 1, 0, &arg1))
2963 return NULL;
2964 arg1 = arg1 / 2;
2965 if ((arg2 = (float(*)[2]) PyMem_NEW(float , 2 * arg1 )) == NULL)
2966 return PyErr_NoMemory();
2967 if (!getifloatarray(args, 1, 0, 2 * arg1 , (float *) arg2))
2968 return NULL;
2969 poly2( arg1 , arg2 );
2970 PyMem_DEL(arg2);
2971 Py_INCREF(Py_None);
2972 return Py_None;
[2]2973}
2974
2975/* void crvn long s float s[3*arg1] */
2976
2977static PyObject *
2978gl_crvn(PyObject *self, PyObject *args)
2979{
[391]2980 long arg1 ;
2981 float (* arg2) [ 3 ] ;
2982 if (!getilongarraysize(args, 1, 0, &arg1))
2983 return NULL;
2984 arg1 = arg1 / 3;
2985 if ((arg2 = (float(*)[3]) PyMem_NEW(float , 3 * arg1 )) == NULL)
2986 return PyErr_NoMemory();
2987 if (!getifloatarray(args, 1, 0, 3 * arg1 , (float *) arg2))
2988 return NULL;
2989 crvn( arg1 , arg2 );
2990 PyMem_DEL(arg2);
2991 Py_INCREF(Py_None);
2992 return Py_None;
[2]2993}
2994
2995/* void rcrvn long s float s[4*arg1] */
2996
2997static PyObject *
2998gl_rcrvn(PyObject *self, PyObject *args)
2999{
[391]3000 long arg1 ;
3001 float (* arg2) [ 4 ] ;
3002 if (!getilongarraysize(args, 1, 0, &arg1))
3003 return NULL;
3004 arg1 = arg1 / 4;
3005 if ((arg2 = (float(*)[4]) PyMem_NEW(float , 4 * arg1 )) == NULL)
3006 return PyErr_NoMemory();
3007 if (!getifloatarray(args, 1, 0, 4 * arg1 , (float *) arg2))
3008 return NULL;
3009 rcrvn( arg1 , arg2 );
3010 PyMem_DEL(arg2);
3011 Py_INCREF(Py_None);
3012 return Py_None;
[2]3013}
3014
3015/* void polf2i long s long s[2*arg1] */
3016
3017static PyObject *
3018gl_polf2i(PyObject *self, PyObject *args)
3019{
[391]3020 long arg1 ;
3021 long (* arg2) [ 2 ] ;
3022 if (!getilongarraysize(args, 1, 0, &arg1))
3023 return NULL;
3024 arg1 = arg1 / 2;
3025 if ((arg2 = (long(*)[2]) PyMem_NEW(long , 2 * arg1 )) == NULL)
3026 return PyErr_NoMemory();
3027 if (!getilongarray(args, 1, 0, 2 * arg1 , (long *) arg2))
3028 return NULL;
3029 polf2i( arg1 , arg2 );
3030 PyMem_DEL(arg2);
3031 Py_INCREF(Py_None);
3032 return Py_None;
[2]3033}
3034
3035/* void polfi long s long s[3*arg1] */
3036
3037static PyObject *
3038gl_polfi(PyObject *self, PyObject *args)
3039{
[391]3040 long arg1 ;
3041 long (* arg2) [ 3 ] ;
3042 if (!getilongarraysize(args, 1, 0, &arg1))
3043 return NULL;
3044 arg1 = arg1 / 3;
3045 if ((arg2 = (long(*)[3]) PyMem_NEW(long , 3 * arg1 )) == NULL)
3046 return PyErr_NoMemory();
3047 if (!getilongarray(args, 1, 0, 3 * arg1 , (long *) arg2))
3048 return NULL;
3049 polfi( arg1 , arg2 );
3050 PyMem_DEL(arg2);
3051 Py_INCREF(Py_None);
3052 return Py_None;
[2]3053}
3054
3055/* void poly2i long s long s[2*arg1] */
3056
3057static PyObject *
3058gl_poly2i(PyObject *self, PyObject *args)
3059{
[391]3060 long arg1 ;
3061 long (* arg2) [ 2 ] ;
3062 if (!getilongarraysize(args, 1, 0, &arg1))
3063 return NULL;
3064 arg1 = arg1 / 2;
3065 if ((arg2 = (long(*)[2]) PyMem_NEW(long , 2 * arg1 )) == NULL)
3066 return PyErr_NoMemory();
3067 if (!getilongarray(args, 1, 0, 2 * arg1 , (long *) arg2))
3068 return NULL;
3069 poly2i( arg1 , arg2 );
3070 PyMem_DEL(arg2);
3071 Py_INCREF(Py_None);
3072 return Py_None;
[2]3073}
3074
3075/* void polyi long s long s[3*arg1] */
3076
3077static PyObject *
3078gl_polyi(PyObject *self, PyObject *args)
3079{
[391]3080 long arg1 ;
3081 long (* arg2) [ 3 ] ;
3082 if (!getilongarraysize(args, 1, 0, &arg1))
3083 return NULL;
3084 arg1 = arg1 / 3;
3085 if ((arg2 = (long(*)[3]) PyMem_NEW(long , 3 * arg1 )) == NULL)
3086 return PyErr_NoMemory();
3087 if (!getilongarray(args, 1, 0, 3 * arg1 , (long *) arg2))
3088 return NULL;
3089 polyi( arg1 , arg2 );
3090 PyMem_DEL(arg2);
3091 Py_INCREF(Py_None);
3092 return Py_None;
[2]3093}
3094
3095/* void polf2s long s short s[2*arg1] */
3096
3097static PyObject *
3098gl_polf2s(PyObject *self, PyObject *args)
3099{
[391]3100 long arg1 ;
3101 short (* arg2) [ 2 ] ;
3102 if (!getilongarraysize(args, 1, 0, &arg1))
3103 return NULL;
3104 arg1 = arg1 / 2;
3105 if ((arg2 = (short(*)[2]) PyMem_NEW(short , 2 * arg1 )) == NULL)
3106 return PyErr_NoMemory();
3107 if (!getishortarray(args, 1, 0, 2 * arg1 , (short *) arg2))
3108 return NULL;
3109 polf2s( arg1 , arg2 );
3110 PyMem_DEL(arg2);
3111 Py_INCREF(Py_None);
3112 return Py_None;
[2]3113}
3114
3115/* void polfs long s short s[3*arg1] */
3116
3117static PyObject *
3118gl_polfs(PyObject *self, PyObject *args)
3119{
[391]3120 long arg1 ;
3121 short (* arg2) [ 3 ] ;
3122 if (!getilongarraysize(args, 1, 0, &arg1))
3123 return NULL;
3124 arg1 = arg1 / 3;
3125 if ((arg2 = (short(*)[3]) PyMem_NEW(short , 3 * arg1 )) == NULL)
3126 return PyErr_NoMemory();
3127 if (!getishortarray(args, 1, 0, 3 * arg1 , (short *) arg2))
3128 return NULL;
3129 polfs( arg1 , arg2 );
3130 PyMem_DEL(arg2);
3131 Py_INCREF(Py_None);
3132 return Py_None;
[2]3133}
3134
3135/* void polys long s short s[3*arg1] */
3136
3137static PyObject *
3138gl_polys(PyObject *self, PyObject *args)
3139{
[391]3140 long arg1 ;
3141 short (* arg2) [ 3 ] ;
3142 if (!getilongarraysize(args, 1, 0, &arg1))
3143 return NULL;
3144 arg1 = arg1 / 3;
3145 if ((arg2 = (short(*)[3]) PyMem_NEW(short , 3 * arg1 )) == NULL)
3146 return PyErr_NoMemory();
3147 if (!getishortarray(args, 1, 0, 3 * arg1 , (short *) arg2))
3148 return NULL;
3149 polys( arg1 , arg2 );
3150 PyMem_DEL(arg2);
3151 Py_INCREF(Py_None);
3152 return Py_None;
[2]3153}
3154
3155/* void poly2s long s short s[2*arg1] */
3156
3157static PyObject *
3158gl_poly2s(PyObject *self, PyObject *args)
3159{
[391]3160 long arg1 ;
3161 short (* arg2) [ 2 ] ;
3162 if (!getilongarraysize(args, 1, 0, &arg1))
3163 return NULL;
3164 arg1 = arg1 / 2;
3165 if ((arg2 = (short(*)[2]) PyMem_NEW(short , 2 * arg1 )) == NULL)
3166 return PyErr_NoMemory();
3167 if (!getishortarray(args, 1, 0, 2 * arg1 , (short *) arg2))
3168 return NULL;
3169 poly2s( arg1 , arg2 );
3170 PyMem_DEL(arg2);
3171 Py_INCREF(Py_None);
3172 return Py_None;
[2]3173}
3174
3175/* void defcursor short s u_short s[128] */
3176
3177static PyObject *
3178gl_defcursor(PyObject *self, PyObject *args)
3179{
[391]3180 short arg1 ;
3181 unsigned short arg2 [ 128 ] ;
3182 if (!getishortarg(args, 2, 0, &arg1))
3183 return NULL;
3184 if (!getishortarray(args, 2, 1, 128 , (short *) arg2))
3185 return NULL;
3186 defcursor( arg1 , arg2 );
3187 Py_INCREF(Py_None);
3188 return Py_None;
[2]3189}
3190
3191/* void writepixels short s u_short s[arg1] */
3192
3193static PyObject *
3194gl_writepixels(PyObject *self, PyObject *args)
3195{
[391]3196 short arg1 ;
3197 unsigned short * arg2 ;
3198 if (!getishortarraysize(args, 1, 0, &arg1))
3199 return NULL;
3200 if ((arg2 = PyMem_NEW(unsigned short , arg1 )) == NULL)
3201 return PyErr_NoMemory();
3202 if (!getishortarray(args, 1, 0, arg1 , (short *) arg2))
3203 return NULL;
3204 writepixels( arg1 , arg2 );
3205 PyMem_DEL(arg2);
3206 Py_INCREF(Py_None);
3207 return Py_None;
[2]3208}
3209
3210/* void defbasis long s float s[4*4] */
3211
3212static PyObject *
3213gl_defbasis(PyObject *self, PyObject *args)
3214{
[391]3215 long arg1 ;
3216 float arg2 [ 4 ] [ 4 ] ;
3217 if (!getilongarg(args, 2, 0, &arg1))
3218 return NULL;
3219 if (!getifloatarray(args, 2, 1, 4 * 4 , (float *) arg2))
3220 return NULL;
3221 defbasis( arg1 , arg2 );
3222 Py_INCREF(Py_None);
3223 return Py_None;
[2]3224}
3225
3226/* void gewrite short s short s[arg1] */
3227
3228static PyObject *
3229gl_gewrite(PyObject *self, PyObject *args)
3230{
[391]3231 short arg1 ;
3232 short * arg2 ;
3233 if (!getishortarraysize(args, 1, 0, &arg1))
3234 return NULL;
3235 if ((arg2 = PyMem_NEW(short , arg1 )) == NULL)
3236 return PyErr_NoMemory();
3237 if (!getishortarray(args, 1, 0, arg1 , arg2))
3238 return NULL;
3239 gewrite( arg1 , arg2 );
3240 PyMem_DEL(arg2);
3241 Py_INCREF(Py_None);
3242 return Py_None;
[2]3243}
3244
3245/* void rotate short s char s */
3246
3247static PyObject *
3248gl_rotate(PyObject *self, PyObject *args)
3249{
[391]3250 short arg1 ;
3251 char arg2 ;
3252 if (!getishortarg(args, 2, 0, &arg1))
3253 return NULL;
3254 if (!getichararg(args, 2, 1, &arg2))
3255 return NULL;
3256 rotate( arg1 , arg2 );
3257 Py_INCREF(Py_None);
3258 return Py_None;
[2]3259}
3260
3261/* void rot float s char s */
3262
3263static PyObject *
3264gl_rot(PyObject *self, PyObject *args)
3265{
[391]3266 float arg1 ;
3267 char arg2 ;
3268 if (!getifloatarg(args, 2, 0, &arg1))
3269 return NULL;
3270 if (!getichararg(args, 2, 1, &arg2))
3271 return NULL;
3272 rot( arg1 , arg2 );
3273 Py_INCREF(Py_None);
3274 return Py_None;
[2]3275}
3276
3277/* void circfi long s long s long s */
3278
3279static PyObject *
3280gl_circfi(PyObject *self, PyObject *args)
3281{
[391]3282 long arg1 ;
3283 long arg2 ;
3284 long arg3 ;
3285 if (!getilongarg(args, 3, 0, &arg1))
3286 return NULL;
3287 if (!getilongarg(args, 3, 1, &arg2))
3288 return NULL;
3289 if (!getilongarg(args, 3, 2, &arg3))
3290 return NULL;
3291 circfi( arg1 , arg2 , arg3 );
3292 Py_INCREF(Py_None);
3293 return Py_None;
[2]3294}
3295
3296/* void circi long s long s long s */
3297
3298static PyObject *
3299gl_circi(PyObject *self, PyObject *args)
3300{
[391]3301 long arg1 ;
3302 long arg2 ;
3303 long arg3 ;
3304 if (!getilongarg(args, 3, 0, &arg1))
3305 return NULL;
3306 if (!getilongarg(args, 3, 1, &arg2))
3307 return NULL;
3308 if (!getilongarg(args, 3, 2, &arg3))
3309 return NULL;
3310 circi( arg1 , arg2 , arg3 );
3311 Py_INCREF(Py_None);
3312 return Py_None;
[2]3313}
3314
3315/* void cmovi long s long s long s */
3316
3317static PyObject *
3318gl_cmovi(PyObject *self, PyObject *args)
3319{
[391]3320 long arg1 ;
3321 long arg2 ;
3322 long arg3 ;
3323 if (!getilongarg(args, 3, 0, &arg1))
3324 return NULL;
3325 if (!getilongarg(args, 3, 1, &arg2))
3326 return NULL;
3327 if (!getilongarg(args, 3, 2, &arg3))
3328 return NULL;
3329 cmovi( arg1 , arg2 , arg3 );
3330 Py_INCREF(Py_None);
3331 return Py_None;
[2]3332}
3333
3334/* void drawi long s long s long s */
3335
3336static PyObject *
3337gl_drawi(PyObject *self, PyObject *args)
3338{
[391]3339 long arg1 ;
3340 long arg2 ;
3341 long arg3 ;
3342 if (!getilongarg(args, 3, 0, &arg1))
3343 return NULL;
3344 if (!getilongarg(args, 3, 1, &arg2))
3345 return NULL;
3346 if (!getilongarg(args, 3, 2, &arg3))
3347 return NULL;
3348 drawi( arg1 , arg2 , arg3 );
3349 Py_INCREF(Py_None);
3350 return Py_None;
[2]3351}
3352
3353/* void movei long s long s long s */
3354
3355static PyObject *
3356gl_movei(PyObject *self, PyObject *args)
3357{
[391]3358 long arg1 ;
3359 long arg2 ;
3360 long arg3 ;
3361 if (!getilongarg(args, 3, 0, &arg1))
3362 return NULL;
3363 if (!getilongarg(args, 3, 1, &arg2))
3364 return NULL;
3365 if (!getilongarg(args, 3, 2, &arg3))
3366 return NULL;
3367 movei( arg1 , arg2 , arg3 );
3368 Py_INCREF(Py_None);
3369 return Py_None;
[2]3370}
3371
3372/* void pnti long s long s long s */
3373
3374static PyObject *
3375gl_pnti(PyObject *self, PyObject *args)
3376{
[391]3377 long arg1 ;
3378 long arg2 ;
3379 long arg3 ;
3380 if (!getilongarg(args, 3, 0, &arg1))
3381 return NULL;
3382 if (!getilongarg(args, 3, 1, &arg2))
3383 return NULL;
3384 if (!getilongarg(args, 3, 2, &arg3))
3385 return NULL;
3386 pnti( arg1 , arg2 , arg3 );
3387 Py_INCREF(Py_None);
3388 return Py_None;
[2]3389}
3390
3391/* void newtag long s long s long s */
3392
3393static PyObject *
3394gl_newtag(PyObject *self, PyObject *args)
3395{
[391]3396 long arg1 ;
3397 long arg2 ;
3398 long arg3 ;
3399 if (!getilongarg(args, 3, 0, &arg1))
3400 return NULL;
3401 if (!getilongarg(args, 3, 1, &arg2))
3402 return NULL;
3403 if (!getilongarg(args, 3, 2, &arg3))
3404 return NULL;
3405 newtag( arg1 , arg2 , arg3 );
3406 Py_INCREF(Py_None);
3407 return Py_None;
[2]3408}
3409
3410/* void pdri long s long s long s */
3411
3412static PyObject *
3413gl_pdri(PyObject *self, PyObject *args)
3414{
[391]3415 long arg1 ;
3416 long arg2 ;
3417 long arg3 ;
3418 if (!getilongarg(args, 3, 0, &arg1))
3419 return NULL;
3420 if (!getilongarg(args, 3, 1, &arg2))
3421 return NULL;
3422 if (!getilongarg(args, 3, 2, &arg3))
3423 return NULL;
3424 pdri( arg1 , arg2 , arg3 );
3425 Py_INCREF(Py_None);
3426 return Py_None;
[2]3427}
3428
3429/* void pmvi long s long s long s */
3430
3431static PyObject *
3432gl_pmvi(PyObject *self, PyObject *args)
3433{
[391]3434 long arg1 ;
3435 long arg2 ;
3436 long arg3 ;
3437 if (!getilongarg(args, 3, 0, &arg1))
3438 return NULL;
3439 if (!getilongarg(args, 3, 1, &arg2))
3440 return NULL;
3441 if (!getilongarg(args, 3, 2, &arg3))
3442 return NULL;
3443 pmvi( arg1 , arg2 , arg3 );
3444 Py_INCREF(Py_None);
3445 return Py_None;
[2]3446}
3447
3448/* void rdri long s long s long s */
3449
3450static PyObject *
3451gl_rdri(PyObject *self, PyObject *args)
3452{
[391]3453 long arg1 ;
3454 long arg2 ;
3455 long arg3 ;
3456 if (!getilongarg(args, 3, 0, &arg1))
3457 return NULL;
3458 if (!getilongarg(args, 3, 1, &arg2))
3459 return NULL;
3460 if (!getilongarg(args, 3, 2, &arg3))
3461 return NULL;
3462 rdri( arg1 , arg2 , arg3 );
3463 Py_INCREF(Py_None);
3464 return Py_None;
[2]3465}
3466
3467/* void rmvi long s long s long s */
3468
3469static PyObject *
3470gl_rmvi(PyObject *self, PyObject *args)
3471{
[391]3472 long arg1 ;
3473 long arg2 ;
3474 long arg3 ;
3475 if (!getilongarg(args, 3, 0, &arg1))
3476 return NULL;
3477 if (!getilongarg(args, 3, 1, &arg2))
3478 return NULL;
3479 if (!getilongarg(args, 3, 2, &arg3))
3480 return NULL;
3481 rmvi( arg1 , arg2 , arg3 );
3482 Py_INCREF(Py_None);
3483 return Py_None;
[2]3484}
3485
3486/* void rpdri long s long s long s */
3487
3488static PyObject *
3489gl_rpdri(PyObject *self, PyObject *args)
3490{
[391]3491 long arg1 ;
3492 long arg2 ;
3493 long arg3 ;
3494 if (!getilongarg(args, 3, 0, &arg1))
3495 return NULL;
3496 if (!getilongarg(args, 3, 1, &arg2))
3497 return NULL;
3498 if (!getilongarg(args, 3, 2, &arg3))
3499 return NULL;
3500 rpdri( arg1 , arg2 , arg3 );
3501 Py_INCREF(Py_None);
3502 return Py_None;
[2]3503}
3504
3505/* void rpmvi long s long s long s */
3506
3507static PyObject *
3508gl_rpmvi(PyObject *self, PyObject *args)
3509{
[391]3510 long arg1 ;
3511 long arg2 ;
3512 long arg3 ;
3513 if (!getilongarg(args, 3, 0, &arg1))
3514 return NULL;
3515 if (!getilongarg(args, 3, 1, &arg2))
3516 return NULL;
3517 if (!getilongarg(args, 3, 2, &arg3))
3518 return NULL;
3519 rpmvi( arg1 , arg2 , arg3 );
3520 Py_INCREF(Py_None);
3521 return Py_None;
[2]3522}
3523
3524/* void xfpti long s long s long s */
3525
3526static PyObject *
3527gl_xfpti(PyObject *self, PyObject *args)
3528{
[391]3529 long arg1 ;
3530 long arg2 ;
3531 long arg3 ;
3532 if (!getilongarg(args, 3, 0, &arg1))
3533 return NULL;
3534 if (!getilongarg(args, 3, 1, &arg2))
3535 return NULL;
3536 if (!getilongarg(args, 3, 2, &arg3))
3537 return NULL;
3538 xfpti( arg1 , arg2 , arg3 );
3539 Py_INCREF(Py_None);
3540 return Py_None;
[2]3541}
3542
3543/* void circ float s float s float s */
3544
3545static PyObject *
3546gl_circ(PyObject *self, PyObject *args)
3547{
[391]3548 float arg1 ;
3549 float arg2 ;
3550 float arg3 ;
3551 if (!getifloatarg(args, 3, 0, &arg1))
3552 return NULL;
3553 if (!getifloatarg(args, 3, 1, &arg2))
3554 return NULL;
3555 if (!getifloatarg(args, 3, 2, &arg3))
3556 return NULL;
3557 circ( arg1 , arg2 , arg3 );
3558 Py_INCREF(Py_None);
3559 return Py_None;
[2]3560}
3561
3562/* void circf float s float s float s */
3563
3564static PyObject *
3565gl_circf(PyObject *self, PyObject *args)
3566{
[391]3567 float arg1 ;
3568 float arg2 ;
3569 float arg3 ;
3570 if (!getifloatarg(args, 3, 0, &arg1))
3571 return NULL;
3572 if (!getifloatarg(args, 3, 1, &arg2))
3573 return NULL;
3574 if (!getifloatarg(args, 3, 2, &arg3))
3575 return NULL;
3576 circf( arg1 , arg2 , arg3 );
3577 Py_INCREF(Py_None);
3578 return Py_None;
[2]3579}
3580
3581/* void cmov float s float s float s */
3582
3583static PyObject *
3584gl_cmov(PyObject *self, PyObject *args)
3585{
[391]3586 float arg1 ;
3587 float arg2 ;
3588 float arg3 ;
3589 if (!getifloatarg(args, 3, 0, &arg1))
3590 return NULL;
3591 if (!getifloatarg(args, 3, 1, &arg2))
3592 return NULL;
3593 if (!getifloatarg(args, 3, 2, &arg3))
3594 return NULL;
3595 cmov( arg1 , arg2 , arg3 );
3596 Py_INCREF(Py_None);
3597 return Py_None;
[2]3598}
3599
3600/* void draw float s float s float s */
3601
3602static PyObject *
3603gl_draw(PyObject *self, PyObject *args)
3604{
[391]3605 float arg1 ;
3606 float arg2 ;
3607 float arg3 ;
3608 if (!getifloatarg(args, 3, 0, &arg1))
3609 return NULL;
3610 if (!getifloatarg(args, 3, 1, &arg2))
3611 return NULL;
3612 if (!getifloatarg(args, 3, 2, &arg3))
3613 return NULL;
3614 draw( arg1 , arg2 , arg3 );
3615 Py_INCREF(Py_None);
3616 return Py_None;
[2]3617}
3618
3619/* void move float s float s float s */
3620
3621static PyObject *
3622gl_move(PyObject *self, PyObject *args)
3623{
[391]3624 float arg1 ;
3625 float arg2 ;
3626 float arg3 ;
3627 if (!getifloatarg(args, 3, 0, &arg1))
3628 return NULL;
3629 if (!getifloatarg(args, 3, 1, &arg2))
3630 return NULL;
3631 if (!getifloatarg(args, 3, 2, &arg3))
3632 return NULL;
3633 move( arg1 , arg2 , arg3 );
3634 Py_INCREF(Py_None);
3635 return Py_None;
[2]3636}
3637
3638/* void pnt float s float s float s */
3639
3640static PyObject *
3641gl_pnt(PyObject *self, PyObject *args)
3642{
[391]3643 float arg1 ;
3644 float arg2 ;
3645 float arg3 ;
3646 if (!getifloatarg(args, 3, 0, &arg1))
3647 return NULL;
3648 if (!getifloatarg(args, 3, 1, &arg2))
3649 return NULL;
3650 if (!getifloatarg(args, 3, 2, &arg3))
3651 return NULL;
3652 pnt( arg1 , arg2 , arg3 );
3653 Py_INCREF(Py_None);
3654 return Py_None;
[2]3655}
3656
3657/* void scale float s float s float s */
3658
3659static PyObject *
3660gl_scale(PyObject *self, PyObject *args)
3661{
[391]3662 float arg1 ;
3663 float arg2 ;
3664 float arg3 ;
3665 if (!getifloatarg(args, 3, 0, &arg1))
3666 return NULL;
3667 if (!getifloatarg(args, 3, 1, &arg2))
3668 return NULL;
3669 if (!getifloatarg(args, 3, 2, &arg3))
3670 return NULL;
3671 scale( arg1 , arg2 , arg3 );
3672 Py_INCREF(Py_None);
3673 return Py_None;
[2]3674}
3675
3676/* void translate float s float s float s */
3677
3678static PyObject *
3679gl_translate(PyObject *self, PyObject *args)
3680{
[391]3681 float arg1 ;
3682 float arg2 ;
3683 float arg3 ;
3684 if (!getifloatarg(args, 3, 0, &arg1))
3685 return NULL;
3686 if (!getifloatarg(args, 3, 1, &arg2))
3687 return NULL;
3688 if (!getifloatarg(args, 3, 2, &arg3))
3689 return NULL;
3690 translate( arg1 , arg2 , arg3 );
3691 Py_INCREF(Py_None);
3692 return Py_None;
[2]3693}
3694
3695/* void pdr float s float s float s */
3696
3697static PyObject *
3698gl_pdr(PyObject *self, PyObject *args)
3699{
[391]3700 float arg1 ;
3701 float arg2 ;
3702 float arg3 ;
3703 if (!getifloatarg(args, 3, 0, &arg1))
3704 return NULL;
3705 if (!getifloatarg(args, 3, 1, &arg2))
3706 return NULL;
3707 if (!getifloatarg(args, 3, 2, &arg3))
3708 return NULL;
3709 pdr( arg1 , arg2 , arg3 );
3710 Py_INCREF(Py_None);
3711 return Py_None;
[2]3712}
3713
3714/* void pmv float s float s float s */
3715
3716static PyObject *
3717gl_pmv(PyObject *self, PyObject *args)
3718{
[391]3719 float arg1 ;
3720 float arg2 ;
3721 float arg3 ;
3722 if (!getifloatarg(args, 3, 0, &arg1))
3723 return NULL;
3724 if (!getifloatarg(args, 3, 1, &arg2))
3725 return NULL;
3726 if (!getifloatarg(args, 3, 2, &arg3))
3727 return NULL;
3728 pmv( arg1 , arg2 , arg3 );
3729 Py_INCREF(Py_None);
3730 return Py_None;
[2]3731}
3732
3733/* void rdr float s float s float s */
3734
3735static PyObject *
3736gl_rdr(PyObject *self, PyObject *args)
3737{
[391]3738 float arg1 ;
3739 float arg2 ;
3740 float arg3 ;
3741 if (!getifloatarg(args, 3, 0, &arg1))
3742 return NULL;
3743 if (!getifloatarg(args, 3, 1, &arg2))
3744 return NULL;
3745 if (!getifloatarg(args, 3, 2, &arg3))
3746 return NULL;
3747 rdr( arg1 , arg2 , arg3 );
3748 Py_INCREF(Py_None);
3749 return Py_None;
[2]3750}
3751
3752/* void rmv float s float s float s */
3753
3754static PyObject *
3755gl_rmv(PyObject *self, PyObject *args)
3756{
[391]3757 float arg1 ;
3758 float arg2 ;
3759 float arg3 ;
3760 if (!getifloatarg(args, 3, 0, &arg1))
3761 return NULL;
3762 if (!getifloatarg(args, 3, 1, &arg2))
3763 return NULL;
3764 if (!getifloatarg(args, 3, 2, &arg3))
3765 return NULL;
3766 rmv( arg1 , arg2 , arg3 );
3767 Py_INCREF(Py_None);
3768 return Py_None;
[2]3769}
3770
3771/* void rpdr float s float s float s */
3772
3773static PyObject *
3774gl_rpdr(PyObject *self, PyObject *args)
3775{
[391]3776 float arg1 ;
3777 float arg2 ;
3778 float arg3 ;
3779 if (!getifloatarg(args, 3, 0, &arg1))
3780 return NULL;
3781 if (!getifloatarg(args, 3, 1, &arg2))
3782 return NULL;
3783 if (!getifloatarg(args, 3, 2, &arg3))
3784 return NULL;
3785 rpdr( arg1 , arg2 , arg3 );
3786 Py_INCREF(Py_None);
3787 return Py_None;
[2]3788}
3789
3790/* void rpmv float s float s float s */
3791
3792static PyObject *
3793gl_rpmv(PyObject *self, PyObject *args)
3794{
[391]3795 float arg1 ;
3796 float arg2 ;
3797 float arg3 ;
3798 if (!getifloatarg(args, 3, 0, &arg1))
3799 return NULL;
3800 if (!getifloatarg(args, 3, 1, &arg2))
3801 return NULL;
3802 if (!getifloatarg(args, 3, 2, &arg3))
3803 return NULL;
3804 rpmv( arg1 , arg2 , arg3 );
3805 Py_INCREF(Py_None);
3806 return Py_None;
[2]3807}
3808
3809/* void xfpt float s float s float s */
3810
3811static PyObject *
3812gl_xfpt(PyObject *self, PyObject *args)
3813{
[391]3814 float arg1 ;
3815 float arg2 ;
3816 float arg3 ;
3817 if (!getifloatarg(args, 3, 0, &arg1))
3818 return NULL;
3819 if (!getifloatarg(args, 3, 1, &arg2))
3820 return NULL;
3821 if (!getifloatarg(args, 3, 2, &arg3))
3822 return NULL;
3823 xfpt( arg1 , arg2 , arg3 );
3824 Py_INCREF(Py_None);
3825 return Py_None;
[2]3826}
3827
3828/* void RGBcolor short s short s short s */
3829
3830static PyObject *
3831gl_RGBcolor(PyObject *self, PyObject *args)
3832{
[391]3833 short arg1 ;
3834 short arg2 ;
3835 short arg3 ;
3836 if (!getishortarg(args, 3, 0, &arg1))
3837 return NULL;
3838 if (!getishortarg(args, 3, 1, &arg2))
3839 return NULL;
3840 if (!getishortarg(args, 3, 2, &arg3))
3841 return NULL;
3842 RGBcolor( arg1 , arg2 , arg3 );
3843 Py_INCREF(Py_None);
3844 return Py_None;
[2]3845}
3846
3847/* void RGBwritemask short s short s short s */
3848
3849static PyObject *
3850gl_RGBwritemask(PyObject *self, PyObject *args)
3851{
[391]3852 short arg1 ;
3853 short arg2 ;
3854 short arg3 ;
3855 if (!getishortarg(args, 3, 0, &arg1))
3856 return NULL;
3857 if (!getishortarg(args, 3, 1, &arg2))
3858 return NULL;
3859 if (!getishortarg(args, 3, 2, &arg3))
3860 return NULL;
3861 RGBwritemask( arg1 , arg2 , arg3 );
3862 Py_INCREF(Py_None);
3863 return Py_None;
[2]3864}
3865
3866/* void setcursor short s short s short s */
3867
3868static PyObject *
3869gl_setcursor(PyObject *self, PyObject *args)
3870{
[391]3871 short arg1 ;
3872 short arg2 ;
3873 short arg3 ;
3874 if (!getishortarg(args, 3, 0, &arg1))
3875 return NULL;
3876 if (!getishortarg(args, 3, 1, &arg2))
3877 return NULL;
3878 if (!getishortarg(args, 3, 2, &arg3))
3879 return NULL;
3880 setcursor( arg1 , arg2 , arg3 );
3881 Py_INCREF(Py_None);
3882 return Py_None;
[2]3883}
3884
3885/* void tie short s short s short s */
3886
3887static PyObject *
3888gl_tie(PyObject *self, PyObject *args)
3889{
[391]3890 short arg1 ;
3891 short arg2 ;
3892 short arg3 ;
3893 if (!getishortarg(args, 3, 0, &arg1))
3894 return NULL;
3895 if (!getishortarg(args, 3, 1, &arg2))
3896 return NULL;
3897 if (!getishortarg(args, 3, 2, &arg3))
3898 return NULL;
3899 tie( arg1 , arg2 , arg3 );
3900 Py_INCREF(Py_None);
3901 return Py_None;
[2]3902}
3903
3904/* void circfs short s short s short s */
3905
3906static PyObject *
3907gl_circfs(PyObject *self, PyObject *args)
3908{
[391]3909 short arg1 ;
3910 short arg2 ;
3911 short arg3 ;
3912 if (!getishortarg(args, 3, 0, &arg1))
3913 return NULL;
3914 if (!getishortarg(args, 3, 1, &arg2))
3915 return NULL;
3916 if (!getishortarg(args, 3, 2, &arg3))
3917 return NULL;
3918 circfs( arg1 , arg2 , arg3 );
3919 Py_INCREF(Py_None);
3920 return Py_None;
[2]3921}
3922
3923/* void circs short s short s short s */
3924
3925static PyObject *
3926gl_circs(PyObject *self, PyObject *args)
3927{
[391]3928 short arg1 ;
3929 short arg2 ;
3930 short arg3 ;
3931 if (!getishortarg(args, 3, 0, &arg1))
3932 return NULL;
3933 if (!getishortarg(args, 3, 1, &arg2))
3934 return NULL;
3935 if (!getishortarg(args, 3, 2, &arg3))
3936 return NULL;
3937 circs( arg1 , arg2 , arg3 );
3938 Py_INCREF(Py_None);
3939 return Py_None;
[2]3940}
3941
3942/* void cmovs short s short s short s */
3943
3944static PyObject *
3945gl_cmovs(PyObject *self, PyObject *args)
3946{
[391]3947 short arg1 ;
3948 short arg2 ;
3949 short arg3 ;
3950 if (!getishortarg(args, 3, 0, &arg1))
3951 return NULL;
3952 if (!getishortarg(args, 3, 1, &arg2))
3953 return NULL;
3954 if (!getishortarg(args, 3, 2, &arg3))
3955 return NULL;
3956 cmovs( arg1 , arg2 , arg3 );
3957 Py_INCREF(Py_None);
3958 return Py_None;
[2]3959}
3960
3961/* void draws short s short s short s */
3962
3963static PyObject *
3964gl_draws(PyObject *self, PyObject *args)
3965{
[391]3966 short arg1 ;
3967 short arg2 ;
3968 short arg3 ;
3969 if (!getishortarg(args, 3, 0, &arg1))
3970 return NULL;
3971 if (!getishortarg(args, 3, 1, &arg2))
3972 return NULL;
3973 if (!getishortarg(args, 3, 2, &arg3))
3974 return NULL;
3975 draws( arg1 , arg2 , arg3 );
3976 Py_INCREF(Py_None);
3977 return Py_None;
[2]3978}
3979
3980/* void moves short s short s short s */
3981
3982static PyObject *
3983gl_moves(PyObject *self, PyObject *args)
3984{
[391]3985 short arg1 ;
3986 short arg2 ;
3987 short arg3 ;
3988 if (!getishortarg(args, 3, 0, &arg1))
3989 return NULL;
3990 if (!getishortarg(args, 3, 1, &arg2))
3991 return NULL;
3992 if (!getishortarg(args, 3, 2, &arg3))
3993 return NULL;
3994 moves( arg1 , arg2 , arg3 );
3995 Py_INCREF(Py_None);
3996 return Py_None;
[2]3997}
3998
3999/* void pdrs short s short s short s */
4000
4001static PyObject *
4002gl_pdrs(PyObject *self, PyObject *args)
4003{
[391]4004 short arg1 ;
4005 short arg2 ;
4006 short arg3 ;
4007 if (!getishortarg(args, 3, 0, &arg1))
4008 return NULL;
4009 if (!getishortarg(args, 3, 1, &arg2))
4010 return NULL;
4011 if (!getishortarg(args, 3, 2, &arg3))
4012 return NULL;
4013 pdrs( arg1 , arg2 , arg3 );
4014 Py_INCREF(Py_None);
4015 return Py_None;
[2]4016}
4017
4018/* void pmvs short s short s short s */
4019
4020static PyObject *
4021gl_pmvs(PyObject *self, PyObject *args)
4022{
[391]4023 short arg1 ;
4024 short arg2 ;
4025 short arg3 ;
4026 if (!getishortarg(args, 3, 0, &arg1))
4027 return NULL;
4028 if (!getishortarg(args, 3, 1, &arg2))
4029 return NULL;
4030 if (!getishortarg(args, 3, 2, &arg3))
4031 return NULL;
4032 pmvs( arg1 , arg2 , arg3 );
4033 Py_INCREF(Py_None);
4034 return Py_None;
[2]4035}
4036
4037/* void pnts short s short s short s */
4038
4039static PyObject *
4040gl_pnts(PyObject *self, PyObject *args)
4041{
[391]4042 short arg1 ;
4043 short arg2 ;
4044 short arg3 ;
4045 if (!getishortarg(args, 3, 0, &arg1))
4046 return NULL;
4047 if (!getishortarg(args, 3, 1, &arg2))
4048 return NULL;
4049 if (!getishortarg(args, 3, 2, &arg3))
4050 return NULL;
4051 pnts( arg1 , arg2 , arg3 );
4052 Py_INCREF(Py_None);
4053 return Py_None;
[2]4054}
4055
4056/* void rdrs short s short s short s */
4057
4058static PyObject *
4059gl_rdrs(PyObject *self, PyObject *args)
4060{
[391]4061 short arg1 ;
4062 short arg2 ;
4063 short arg3 ;
4064 if (!getishortarg(args, 3, 0, &arg1))
4065 return NULL;
4066 if (!getishortarg(args, 3, 1, &arg2))
4067 return NULL;
4068 if (!getishortarg(args, 3, 2, &arg3))
4069 return NULL;
4070 rdrs( arg1 , arg2 , arg3 );
4071 Py_INCREF(Py_None);
4072 return Py_None;
[2]4073}
4074
4075/* void rmvs short s short s short s */
4076
4077static PyObject *
4078gl_rmvs(PyObject *self, PyObject *args)
4079{
[391]4080 short arg1 ;
4081 short arg2 ;
4082 short arg3 ;
4083 if (!getishortarg(args, 3, 0, &arg1))
4084 return NULL;
4085 if (!getishortarg(args, 3, 1, &arg2))
4086 return NULL;
4087 if (!getishortarg(args, 3, 2, &arg3))
4088 return NULL;
4089 rmvs( arg1 , arg2 , arg3 );
4090 Py_INCREF(Py_None);
4091 return Py_None;
[2]4092}
4093
4094/* void rpdrs short s short s short s */
4095
4096static PyObject *
4097gl_rpdrs(PyObject *self, PyObject *args)
4098{
[391]4099 short arg1 ;
4100 short arg2 ;
4101 short arg3 ;
4102 if (!getishortarg(args, 3, 0, &arg1))
4103 return NULL;
4104 if (!getishortarg(args, 3, 1, &arg2))
4105 return NULL;
4106 if (!getishortarg(args, 3, 2, &arg3))
4107 return NULL;
4108 rpdrs( arg1 , arg2 , arg3 );
4109 Py_INCREF(Py_None);
4110 return Py_None;
[2]4111}
4112
4113/* void rpmvs short s short s short s */
4114
4115static PyObject *
4116gl_rpmvs(PyObject *self, PyObject *args)
4117{
[391]4118 short arg1 ;
4119 short arg2 ;
4120 short arg3 ;
4121 if (!getishortarg(args, 3, 0, &arg1))
4122 return NULL;
4123 if (!getishortarg(args, 3, 1, &arg2))
4124 return NULL;
4125 if (!getishortarg(args, 3, 2, &arg3))
4126 return NULL;
4127 rpmvs( arg1 , arg2 , arg3 );
4128 Py_INCREF(Py_None);
4129 return Py_None;
[2]4130}
4131
4132/* void xfpts short s short s short s */
4133
4134static PyObject *
4135gl_xfpts(PyObject *self, PyObject *args)
4136{
[391]4137 short arg1 ;
4138 short arg2 ;
4139 short arg3 ;
4140 if (!getishortarg(args, 3, 0, &arg1))
4141 return NULL;
4142 if (!getishortarg(args, 3, 1, &arg2))
4143 return NULL;
4144 if (!getishortarg(args, 3, 2, &arg3))
4145 return NULL;
4146 xfpts( arg1 , arg2 , arg3 );
4147 Py_INCREF(Py_None);
4148 return Py_None;
[2]4149}
4150
4151/* void curorigin short s short s short s */
4152
4153static PyObject *
4154gl_curorigin(PyObject *self, PyObject *args)
4155{
[391]4156 short arg1 ;
4157 short arg2 ;
4158 short arg3 ;
4159 if (!getishortarg(args, 3, 0, &arg1))
4160 return NULL;
4161 if (!getishortarg(args, 3, 1, &arg2))
4162 return NULL;
4163 if (!getishortarg(args, 3, 2, &arg3))
4164 return NULL;
4165 curorigin( arg1 , arg2 , arg3 );
4166 Py_INCREF(Py_None);
4167 return Py_None;
[2]4168}
4169
4170/* void cyclemap short s short s short s */
4171
4172static PyObject *
4173gl_cyclemap(PyObject *self, PyObject *args)
4174{
[391]4175 short arg1 ;
4176 short arg2 ;
4177 short arg3 ;
4178 if (!getishortarg(args, 3, 0, &arg1))
4179 return NULL;
4180 if (!getishortarg(args, 3, 1, &arg2))
4181 return NULL;
4182 if (!getishortarg(args, 3, 2, &arg3))
4183 return NULL;
4184 cyclemap( arg1 , arg2 , arg3 );
4185 Py_INCREF(Py_None);
4186 return Py_None;
[2]4187}
4188
4189/* void patch float s[4*4] float s[4*4] float s[4*4] */
4190
4191static PyObject *
4192gl_patch(PyObject *self, PyObject *args)
4193{
[391]4194 float arg1 [ 4 ] [ 4 ] ;
4195 float arg2 [ 4 ] [ 4 ] ;
4196 float arg3 [ 4 ] [ 4 ] ;
4197 if (!getifloatarray(args, 3, 0, 4 * 4 , (float *) arg1))
4198 return NULL;
4199 if (!getifloatarray(args, 3, 1, 4 * 4 , (float *) arg2))
4200 return NULL;
4201 if (!getifloatarray(args, 3, 2, 4 * 4 , (float *) arg3))
4202 return NULL;
4203 patch( arg1 , arg2 , arg3 );
4204 Py_INCREF(Py_None);
4205 return Py_None;
[2]4206}
4207
4208/* void splf long s float s[3*arg1] u_short s[arg1] */
4209
4210static PyObject *
4211gl_splf(PyObject *self, PyObject *args)
4212{
[391]4213 long arg1 ;
4214 float (* arg2) [ 3 ] ;
4215 unsigned short * arg3 ;
4216 if (!getilongarraysize(args, 2, 0, &arg1))
4217 return NULL;
4218 arg1 = arg1 / 3;
4219 if ((arg2 = (float(*)[3]) PyMem_NEW(float , 3 * arg1 )) == NULL)
4220 return PyErr_NoMemory();
4221 if (!getifloatarray(args, 2, 0, 3 * arg1 , (float *) arg2))
4222 return NULL;
4223 if ((arg3 = PyMem_NEW(unsigned short , arg1 )) == NULL)
4224 return PyErr_NoMemory();
4225 if (!getishortarray(args, 2, 1, arg1 , (short *) arg3))
4226 return NULL;
4227 splf( arg1 , arg2 , arg3 );
4228 PyMem_DEL(arg2);
4229 PyMem_DEL(arg3);
4230 Py_INCREF(Py_None);
4231 return Py_None;
[2]4232}
4233
4234/* void splf2 long s float s[2*arg1] u_short s[arg1] */
4235
4236static PyObject *
4237gl_splf2(PyObject *self, PyObject *args)
4238{
[391]4239 long arg1 ;
4240 float (* arg2) [ 2 ] ;
4241 unsigned short * arg3 ;
4242 if (!getilongarraysize(args, 2, 0, &arg1))
4243 return NULL;
4244 arg1 = arg1 / 2;
4245 if ((arg2 = (float(*)[2]) PyMem_NEW(float , 2 * arg1 )) == NULL)
4246 return PyErr_NoMemory();
4247 if (!getifloatarray(args, 2, 0, 2 * arg1 , (float *) arg2))
4248 return NULL;
4249 if ((arg3 = PyMem_NEW(unsigned short , arg1 )) == NULL)
4250 return PyErr_NoMemory();
4251 if (!getishortarray(args, 2, 1, arg1 , (short *) arg3))
4252 return NULL;
4253 splf2( arg1 , arg2 , arg3 );
4254 PyMem_DEL(arg2);
4255 PyMem_DEL(arg3);
4256 Py_INCREF(Py_None);
4257 return Py_None;
[2]4258}
4259
4260/* void splfi long s long s[3*arg1] u_short s[arg1] */
4261
4262static PyObject *
4263gl_splfi(PyObject *self, PyObject *args)
4264{
[391]4265 long arg1 ;
4266 long (* arg2) [ 3 ] ;
4267 unsigned short * arg3 ;
4268 if (!getilongarraysize(args, 2, 0, &arg1))
4269 return NULL;
4270 arg1 = arg1 / 3;
4271 if ((arg2 = (long(*)[3]) PyMem_NEW(long , 3 * arg1 )) == NULL)
4272 return PyErr_NoMemory();
4273 if (!getilongarray(args, 2, 0, 3 * arg1 , (long *) arg2))
4274 return NULL;
4275 if ((arg3 = PyMem_NEW(unsigned short , arg1 )) == NULL)
4276 return PyErr_NoMemory();
4277 if (!getishortarray(args, 2, 1, arg1 , (short *) arg3))
4278 return NULL;
4279 splfi( arg1 , arg2 , arg3 );
4280 PyMem_DEL(arg2);
4281 PyMem_DEL(arg3);
4282 Py_INCREF(Py_None);
4283 return Py_None;
[2]4284}
4285
4286/* void splf2i long s long s[2*arg1] u_short s[arg1] */
4287
4288static PyObject *
4289gl_splf2i(PyObject *self, PyObject *args)
4290{
[391]4291 long arg1 ;
4292 long (* arg2) [ 2 ] ;
4293 unsigned short * arg3 ;
4294 if (!getilongarraysize(args, 2, 0, &arg1))
4295 return NULL;
4296 arg1 = arg1 / 2;
4297 if ((arg2 = (long(*)[2]) PyMem_NEW(long , 2 * arg1 )) == NULL)
4298 return PyErr_NoMemory();
4299 if (!getilongarray(args, 2, 0, 2 * arg1 , (long *) arg2))
4300 return NULL;
4301 if ((arg3 = PyMem_NEW(unsigned short , arg1 )) == NULL)
4302 return PyErr_NoMemory();
4303 if (!getishortarray(args, 2, 1, arg1 , (short *) arg3))
4304 return NULL;
4305 splf2i( arg1 , arg2 , arg3 );
4306 PyMem_DEL(arg2);
4307 PyMem_DEL(arg3);
4308 Py_INCREF(Py_None);
4309 return Py_None;
[2]4310}
4311
4312/* void splfs long s short s[3*arg1] u_short s[arg1] */
4313
4314static PyObject *
4315gl_splfs(PyObject *self, PyObject *args)
4316{
[391]4317 long arg1 ;
4318 short (* arg2) [ 3 ] ;
4319 unsigned short * arg3 ;
4320 if (!getilongarraysize(args, 2, 0, &arg1))
4321 return NULL;
4322 arg1 = arg1 / 3;
4323 if ((arg2 = (short(*)[3]) PyMem_NEW(short , 3 * arg1 )) == NULL)
4324 return PyErr_NoMemory();
4325 if (!getishortarray(args, 2, 0, 3 * arg1 , (short *) arg2))
4326 return NULL;
4327 if ((arg3 = PyMem_NEW(unsigned short , arg1 )) == NULL)
4328 return PyErr_NoMemory();
4329 if (!getishortarray(args, 2, 1, arg1 , (short *) arg3))
4330 return NULL;
4331 splfs( arg1 , arg2 , arg3 );
4332 PyMem_DEL(arg2);
4333 PyMem_DEL(arg3);
4334 Py_INCREF(Py_None);
4335 return Py_None;
[2]4336}
4337
4338/* void splf2s long s short s[2*arg1] u_short s[arg1] */
4339
4340static PyObject *
4341gl_splf2s(PyObject *self, PyObject *args)
4342{
[391]4343 long arg1 ;
4344 short (* arg2) [ 2 ] ;
4345 unsigned short * arg3 ;
4346 if (!getilongarraysize(args, 2, 0, &arg1))
4347 return NULL;
4348 arg1 = arg1 / 2;
4349 if ((arg2 = (short(*)[2]) PyMem_NEW(short , 2 * arg1 )) == NULL)
4350 return PyErr_NoMemory();
4351 if (!getishortarray(args, 2, 0, 2 * arg1 , (short *) arg2))
4352 return NULL;
4353 if ((arg3 = PyMem_NEW(unsigned short , arg1 )) == NULL)
4354 return PyErr_NoMemory();
4355 if (!getishortarray(args, 2, 1, arg1 , (short *) arg3))
4356 return NULL;
4357 splf2s( arg1 , arg2 , arg3 );
4358 PyMem_DEL(arg2);
4359 PyMem_DEL(arg3);
4360 Py_INCREF(Py_None);
4361 return Py_None;
[2]4362}
4363
4364/* void rpatch float s[4*4] float s[4*4] float s[4*4] float s[4*4] */
4365
4366static PyObject *
4367gl_rpatch(PyObject *self, PyObject *args)
4368{
[391]4369 float arg1 [ 4 ] [ 4 ] ;
4370 float arg2 [ 4 ] [ 4 ] ;
4371 float arg3 [ 4 ] [ 4 ] ;
4372 float arg4 [ 4 ] [ 4 ] ;
4373 if (!getifloatarray(args, 4, 0, 4 * 4 , (float *) arg1))
4374 return NULL;
4375 if (!getifloatarray(args, 4, 1, 4 * 4 , (float *) arg2))
4376 return NULL;
4377 if (!getifloatarray(args, 4, 2, 4 * 4 , (float *) arg3))
4378 return NULL;
4379 if (!getifloatarray(args, 4, 3, 4 * 4 , (float *) arg4))
4380 return NULL;
4381 rpatch( arg1 , arg2 , arg3 , arg4 );
4382 Py_INCREF(Py_None);
4383 return Py_None;
[2]4384}
4385
4386/* void ortho2 float s float s float s float s */
4387
4388static PyObject *
4389gl_ortho2(PyObject *self, PyObject *args)
4390{
[391]4391 float arg1 ;
4392 float arg2 ;
4393 float arg3 ;
4394 float arg4 ;
4395 if (!getifloatarg(args, 4, 0, &arg1))
4396 return NULL;
4397 if (!getifloatarg(args, 4, 1, &arg2))
4398 return NULL;
4399 if (!getifloatarg(args, 4, 2, &arg3))
4400 return NULL;
4401 if (!getifloatarg(args, 4, 3, &arg4))
4402 return NULL;
4403 ortho2( arg1 , arg2 , arg3 , arg4 );
4404 Py_INCREF(Py_None);
4405 return Py_None;
[2]4406}
4407
4408/* void rect float s float s float s float s */
4409
4410static PyObject *
4411gl_rect(PyObject *self, PyObject *args)
4412{
[391]4413 float arg1 ;
4414 float arg2 ;
4415 float arg3 ;
4416 float arg4 ;
4417 if (!getifloatarg(args, 4, 0, &arg1))
4418 return NULL;
4419 if (!getifloatarg(args, 4, 1, &arg2))
4420 return NULL;
4421 if (!getifloatarg(args, 4, 2, &arg3))
4422 return NULL;
4423 if (!getifloatarg(args, 4, 3, &arg4))
4424 return NULL;
4425 rect( arg1 , arg2 , arg3 , arg4 );
4426 Py_INCREF(Py_None);
4427 return Py_None;
[2]4428}
4429
4430/* void rectf float s float s float s float s */
4431
4432static PyObject *
4433gl_rectf(PyObject *self, PyObject *args)
4434{
[391]4435 float arg1 ;
4436 float arg2 ;
4437 float arg3 ;
4438 float arg4 ;
4439 if (!getifloatarg(args, 4, 0, &arg1))
4440 return NULL;
4441 if (!getifloatarg(args, 4, 1, &arg2))
4442 return NULL;
4443 if (!getifloatarg(args, 4, 2, &arg3))
4444 return NULL;
4445 if (!getifloatarg(args, 4, 3, &arg4))
4446 return NULL;
4447 rectf( arg1 , arg2 , arg3 , arg4 );
4448 Py_INCREF(Py_None);
4449 return Py_None;
[2]4450}
4451
4452/* void xfpt4 float s float s float s float s */
4453
4454static PyObject *
4455gl_xfpt4(PyObject *self, PyObject *args)
4456{
[391]4457 float arg1 ;
4458 float arg2 ;
4459 float arg3 ;
4460 float arg4 ;
4461 if (!getifloatarg(args, 4, 0, &arg1))
4462 return NULL;
4463 if (!getifloatarg(args, 4, 1, &arg2))
4464 return NULL;
4465 if (!getifloatarg(args, 4, 2, &arg3))
4466 return NULL;
4467 if (!getifloatarg(args, 4, 3, &arg4))
4468 return NULL;
4469 xfpt4( arg1 , arg2 , arg3 , arg4 );
4470 Py_INCREF(Py_None);
4471 return Py_None;
[2]4472}
4473
4474/* void textport short s short s short s short s */
4475
4476static PyObject *
4477gl_textport(PyObject *self, PyObject *args)
4478{
[391]4479 short arg1 ;
4480 short arg2 ;
4481 short arg3 ;
4482 short arg4 ;
4483 if (!getishortarg(args, 4, 0, &arg1))
4484 return NULL;
4485 if (!getishortarg(args, 4, 1, &arg2))
4486 return NULL;
4487 if (!getishortarg(args, 4, 2, &arg3))
4488 return NULL;
4489 if (!getishortarg(args, 4, 3, &arg4))
4490 return NULL;
4491 textport( arg1 , arg2 , arg3 , arg4 );
4492 Py_INCREF(Py_None);
4493 return Py_None;
[2]4494}
4495
4496/* void mapcolor short s short s short s short s */
4497
4498static PyObject *
4499gl_mapcolor(PyObject *self, PyObject *args)
4500{
[391]4501 short arg1 ;
4502 short arg2 ;
4503 short arg3 ;
4504 short arg4 ;
4505 if (!getishortarg(args, 4, 0, &arg1))
4506 return NULL;
4507 if (!getishortarg(args, 4, 1, &arg2))
4508 return NULL;
4509 if (!getishortarg(args, 4, 2, &arg3))
4510 return NULL;
4511 if (!getishortarg(args, 4, 3, &arg4))
4512 return NULL;
4513 mapcolor( arg1 , arg2 , arg3 , arg4 );
4514 Py_INCREF(Py_None);
4515 return Py_None;
[2]4516}
4517
4518/* void scrmask short s short s short s short s */
4519
4520static PyObject *
4521gl_scrmask(PyObject *self, PyObject *args)
4522{
[391]4523 short arg1 ;
4524 short arg2 ;
4525 short arg3 ;
4526 short arg4 ;
4527 if (!getishortarg(args, 4, 0, &arg1))
4528 return NULL;
4529 if (!getishortarg(args, 4, 1, &arg2))
4530 return NULL;
4531 if (!getishortarg(args, 4, 2, &arg3))
4532 return NULL;
4533 if (!getishortarg(args, 4, 3, &arg4))
4534 return NULL;
4535 scrmask( arg1 , arg2 , arg3 , arg4 );
4536 Py_INCREF(Py_None);
4537 return Py_None;
[2]4538}
4539
4540/* void setvaluator short s short s short s short s */
4541
4542static PyObject *
4543gl_setvaluator(PyObject *self, PyObject *args)
4544{
[391]4545 short arg1 ;
4546 short arg2 ;
4547 short arg3 ;
4548 short arg4 ;
4549 if (!getishortarg(args, 4, 0, &arg1))
4550 return NULL;
4551 if (!getishortarg(args, 4, 1, &arg2))
4552 return NULL;
4553 if (!getishortarg(args, 4, 2, &arg3))
4554 return NULL;
4555 if (!getishortarg(args, 4, 3, &arg4))
4556 return NULL;
4557 setvaluator( arg1 , arg2 , arg3 , arg4 );
4558 Py_INCREF(Py_None);
4559 return Py_None;
[2]4560}
4561
4562/* void viewport short s short s short s short s */
4563
4564static PyObject *
4565gl_viewport(PyObject *self, PyObject *args)
4566{
[391]4567 short arg1 ;
4568 short arg2 ;
4569 short arg3 ;
4570 short arg4 ;
4571 if (!getishortarg(args, 4, 0, &arg1))
4572 return NULL;
4573 if (!getishortarg(args, 4, 1, &arg2))
4574 return NULL;
4575 if (!getishortarg(args, 4, 2, &arg3))
4576 return NULL;
4577 if (!getishortarg(args, 4, 3, &arg4))
4578 return NULL;
4579 viewport( arg1 , arg2 , arg3 , arg4 );
4580 Py_INCREF(Py_None);
4581 return Py_None;
[2]4582}
4583
4584/* void shaderange short s short s short s short s */
4585
4586static PyObject *
4587gl_shaderange(PyObject *self, PyObject *args)
4588{
[391]4589 short arg1 ;
4590 short arg2 ;
4591 short arg3 ;
4592 short arg4 ;
4593 if (!getishortarg(args, 4, 0, &arg1))
4594 return NULL;
4595 if (!getishortarg(args, 4, 1, &arg2))
4596 return NULL;
4597 if (!getishortarg(args, 4, 2, &arg3))
4598 return NULL;
4599 if (!getishortarg(args, 4, 3, &arg4))
4600 return NULL;
4601 shaderange( arg1 , arg2 , arg3 , arg4 );
4602 Py_INCREF(Py_None);
4603 return Py_None;
[2]4604}
4605
4606/* void xfpt4s short s short s short s short s */
4607
4608static PyObject *
4609gl_xfpt4s(PyObject *self, PyObject *args)
4610{
[391]4611 short arg1 ;
4612 short arg2 ;
4613 short arg3 ;
4614 short arg4 ;
4615 if (!getishortarg(args, 4, 0, &arg1))
4616 return NULL;
4617 if (!getishortarg(args, 4, 1, &arg2))
4618 return NULL;
4619 if (!getishortarg(args, 4, 2, &arg3))
4620 return NULL;
4621 if (!getishortarg(args, 4, 3, &arg4))
4622 return NULL;
4623 xfpt4s( arg1 , arg2 , arg3 , arg4 );
4624 Py_INCREF(Py_None);
4625 return Py_None;
[2]4626}
4627
4628/* void rectfi long s long s long s long s */
4629
4630static PyObject *
4631gl_rectfi(PyObject *self, PyObject *args)
4632{
[391]4633 long arg1 ;
4634 long arg2 ;
4635 long arg3 ;
4636 long arg4 ;
4637 if (!getilongarg(args, 4, 0, &arg1))
4638 return NULL;
4639 if (!getilongarg(args, 4, 1, &arg2))
4640 return NULL;
4641 if (!getilongarg(args, 4, 2, &arg3))
4642 return NULL;
4643 if (!getilongarg(args, 4, 3, &arg4))
4644 return NULL;
4645 rectfi( arg1 , arg2 , arg3 , arg4 );
4646 Py_INCREF(Py_None);
4647 return Py_None;
[2]4648}
4649
4650/* void recti long s long s long s long s */
4651
4652static PyObject *
4653gl_recti(PyObject *self, PyObject *args)
4654{
[391]4655 long arg1 ;
4656 long arg2 ;
4657 long arg3 ;
4658 long arg4 ;
4659 if (!getilongarg(args, 4, 0, &arg1))
4660 return NULL;
4661 if (!getilongarg(args, 4, 1, &arg2))
4662 return NULL;
4663 if (!getilongarg(args, 4, 2, &arg3))
4664 return NULL;
4665 if (!getilongarg(args, 4, 3, &arg4))
4666 return NULL;
4667 recti( arg1 , arg2 , arg3 , arg4 );
4668 Py_INCREF(Py_None);
4669 return Py_None;
[2]4670}
4671
4672/* void xfpt4i long s long s long s long s */
4673
4674static PyObject *
4675gl_xfpt4i(PyObject *self, PyObject *args)
4676{
[391]4677 long arg1 ;
4678 long arg2 ;
4679 long arg3 ;
4680 long arg4 ;
4681 if (!getilongarg(args, 4, 0, &arg1))
4682 return NULL;
4683 if (!getilongarg(args, 4, 1, &arg2))
4684 return NULL;
4685 if (!getilongarg(args, 4, 2, &arg3))
4686 return NULL;
4687 if (!getilongarg(args, 4, 3, &arg4))
4688 return NULL;
4689 xfpt4i( arg1 , arg2 , arg3 , arg4 );
4690 Py_INCREF(Py_None);
4691 return Py_None;
[2]4692}
4693
4694/* void prefposition long s long s long s long s */
4695
4696static PyObject *
4697gl_prefposition(PyObject *self, PyObject *args)
4698{
[391]4699 long arg1 ;
4700 long arg2 ;
4701 long arg3 ;
4702 long arg4 ;
4703 if (!getilongarg(args, 4, 0, &arg1))
4704 return NULL;
4705 if (!getilongarg(args, 4, 1, &arg2))
4706 return NULL;
4707 if (!getilongarg(args, 4, 2, &arg3))
4708 return NULL;
4709 if (!getilongarg(args, 4, 3, &arg4))
4710 return NULL;
4711 prefposition( arg1 , arg2 , arg3 , arg4 );
4712 Py_INCREF(Py_None);
4713 return Py_None;
[2]4714}
4715
4716/* void arc float s float s float s short s short s */
4717
4718static PyObject *
4719gl_arc(PyObject *self, PyObject *args)
4720{
[391]4721 float arg1 ;
4722 float arg2 ;
4723 float arg3 ;
4724 short arg4 ;
4725 short arg5 ;
4726 if (!getifloatarg(args, 5, 0, &arg1))
4727 return NULL;
4728 if (!getifloatarg(args, 5, 1, &arg2))
4729 return NULL;
4730 if (!getifloatarg(args, 5, 2, &arg3))
4731 return NULL;
4732 if (!getishortarg(args, 5, 3, &arg4))
4733 return NULL;
4734 if (!getishortarg(args, 5, 4, &arg5))
4735 return NULL;
4736 arc( arg1 , arg2 , arg3 , arg4 , arg5 );
4737 Py_INCREF(Py_None);
4738 return Py_None;
[2]4739}
4740
4741/* void arcf float s float s float s short s short s */
4742
4743static PyObject *
4744gl_arcf(PyObject *self, PyObject *args)
4745{
[391]4746 float arg1 ;
4747 float arg2 ;
4748 float arg3 ;
4749 short arg4 ;
4750 short arg5 ;
4751 if (!getifloatarg(args, 5, 0, &arg1))
4752 return NULL;
4753 if (!getifloatarg(args, 5, 1, &arg2))
4754 return NULL;
4755 if (!getifloatarg(args, 5, 2, &arg3))
4756 return NULL;
4757 if (!getishortarg(args, 5, 3, &arg4))
4758 return NULL;
4759 if (!getishortarg(args, 5, 4, &arg5))
4760 return NULL;
4761 arcf( arg1 , arg2 , arg3 , arg4 , arg5 );
4762 Py_INCREF(Py_None);
4763 return Py_None;
[2]4764}
4765
4766/* void arcfi long s long s long s short s short s */
4767
4768static PyObject *
4769gl_arcfi(PyObject *self, PyObject *args)
4770{
[391]4771 long arg1 ;
4772 long arg2 ;
4773 long arg3 ;
4774 short arg4 ;
4775 short arg5 ;
4776 if (!getilongarg(args, 5, 0, &arg1))
4777 return NULL;
4778 if (!getilongarg(args, 5, 1, &arg2))
4779 return NULL;
4780 if (!getilongarg(args, 5, 2, &arg3))
4781 return NULL;
4782 if (!getishortarg(args, 5, 3, &arg4))
4783 return NULL;
4784 if (!getishortarg(args, 5, 4, &arg5))
4785 return NULL;
4786 arcfi( arg1 , arg2 , arg3 , arg4 , arg5 );
4787 Py_INCREF(Py_None);
4788 return Py_None;
[2]4789}
4790
4791/* void arci long s long s long s short s short s */
4792
4793static PyObject *
4794gl_arci(PyObject *self, PyObject *args)
4795{
[391]4796 long arg1 ;
4797 long arg2 ;
4798 long arg3 ;
4799 short arg4 ;
4800 short arg5 ;
4801 if (!getilongarg(args, 5, 0, &arg1))
4802 return NULL;
4803 if (!getilongarg(args, 5, 1, &arg2))
4804 return NULL;
4805 if (!getilongarg(args, 5, 2, &arg3))
4806 return NULL;
4807 if (!getishortarg(args, 5, 3, &arg4))
4808 return NULL;
4809 if (!getishortarg(args, 5, 4, &arg5))
4810 return NULL;
4811 arci( arg1 , arg2 , arg3 , arg4 , arg5 );
4812 Py_INCREF(Py_None);
4813 return Py_None;
[2]4814}
4815
4816/* void bbox2 short s short s float s float s float s float s */
4817
4818static PyObject *
4819gl_bbox2(PyObject *self, PyObject *args)
4820{
[391]4821 short arg1 ;
4822 short arg2 ;
4823 float arg3 ;
4824 float arg4 ;
4825 float arg5 ;
4826 float arg6 ;
4827 if (!getishortarg(args, 6, 0, &arg1))
4828 return NULL;
4829 if (!getishortarg(args, 6, 1, &arg2))
4830 return NULL;
4831 if (!getifloatarg(args, 6, 2, &arg3))
4832 return NULL;
4833 if (!getifloatarg(args, 6, 3, &arg4))
4834 return NULL;
4835 if (!getifloatarg(args, 6, 4, &arg5))
4836 return NULL;
4837 if (!getifloatarg(args, 6, 5, &arg6))
4838 return NULL;
4839 bbox2( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 );
4840 Py_INCREF(Py_None);
4841 return Py_None;
[2]4842}
4843
4844/* void bbox2i short s short s long s long s long s long s */
4845
4846static PyObject *
4847gl_bbox2i(PyObject *self, PyObject *args)
4848{
[391]4849 short arg1 ;
4850 short arg2 ;
4851 long arg3 ;
4852 long arg4 ;
4853 long arg5 ;
4854 long arg6 ;
4855 if (!getishortarg(args, 6, 0, &arg1))
4856 return NULL;
4857 if (!getishortarg(args, 6, 1, &arg2))
4858 return NULL;
4859 if (!getilongarg(args, 6, 2, &arg3))
4860 return NULL;
4861 if (!getilongarg(args, 6, 3, &arg4))
4862 return NULL;
4863 if (!getilongarg(args, 6, 4, &arg5))
4864 return NULL;
4865 if (!getilongarg(args, 6, 5, &arg6))
4866 return NULL;
4867 bbox2i( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 );
4868 Py_INCREF(Py_None);
4869 return Py_None;
[2]4870}
4871
4872/* void bbox2s short s short s short s short s short s short s */
4873
4874static PyObject *
4875gl_bbox2s(PyObject *self, PyObject *args)
4876{
[391]4877 short arg1 ;
4878 short arg2 ;
4879 short arg3 ;
4880 short arg4 ;
4881 short arg5 ;
4882 short arg6 ;
4883 if (!getishortarg(args, 6, 0, &arg1))
4884 return NULL;
4885 if (!getishortarg(args, 6, 1, &arg2))
4886 return NULL;
4887 if (!getishortarg(args, 6, 2, &arg3))
4888 return NULL;
4889 if (!getishortarg(args, 6, 3, &arg4))
4890 return NULL;
4891 if (!getishortarg(args, 6, 4, &arg5))
4892 return NULL;
4893 if (!getishortarg(args, 6, 5, &arg6))
4894 return NULL;
4895 bbox2s( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 );
4896 Py_INCREF(Py_None);
4897 return Py_None;
[2]4898}
4899
4900/* void blink short s short s short s short s short s */
4901
4902static PyObject *
4903gl_blink(PyObject *self, PyObject *args)
4904{
[391]4905 short arg1 ;
4906 short arg2 ;
4907 short arg3 ;
4908 short arg4 ;
4909 short arg5 ;
4910 if (!getishortarg(args, 5, 0, &arg1))
4911 return NULL;
4912 if (!getishortarg(args, 5, 1, &arg2))
4913 return NULL;
4914 if (!getishortarg(args, 5, 2, &arg3))
4915 return NULL;
4916 if (!getishortarg(args, 5, 3, &arg4))
4917 return NULL;
4918 if (!getishortarg(args, 5, 4, &arg5))
4919 return NULL;
4920 blink( arg1 , arg2 , arg3 , arg4 , arg5 );
4921 Py_INCREF(Py_None);
4922 return Py_None;
[2]4923}
4924
4925/* void ortho float s float s float s float s float s float s */
4926
4927static PyObject *
4928gl_ortho(PyObject *self, PyObject *args)
4929{
[391]4930 float arg1 ;
4931 float arg2 ;
4932 float arg3 ;
4933 float arg4 ;
4934 float arg5 ;
4935 float arg6 ;
4936 if (!getifloatarg(args, 6, 0, &arg1))
4937 return NULL;
4938 if (!getifloatarg(args, 6, 1, &arg2))
4939 return NULL;
4940 if (!getifloatarg(args, 6, 2, &arg3))
4941 return NULL;
4942 if (!getifloatarg(args, 6, 3, &arg4))
4943 return NULL;
4944 if (!getifloatarg(args, 6, 4, &arg5))
4945 return NULL;
4946 if (!getifloatarg(args, 6, 5, &arg6))
4947 return NULL;
4948 ortho( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 );
4949 Py_INCREF(Py_None);
4950 return Py_None;
[2]4951}
4952
4953/* void window float s float s float s float s float s float s */
4954
4955static PyObject *
4956gl_window(PyObject *self, PyObject *args)
4957{
[391]4958 float arg1 ;
4959 float arg2 ;
4960 float arg3 ;
4961 float arg4 ;
4962 float arg5 ;
4963 float arg6 ;
4964 if (!getifloatarg(args, 6, 0, &arg1))
4965 return NULL;
4966 if (!getifloatarg(args, 6, 1, &arg2))
4967 return NULL;
4968 if (!getifloatarg(args, 6, 2, &arg3))
4969 return NULL;
4970 if (!getifloatarg(args, 6, 3, &arg4))
4971 return NULL;
4972 if (!getifloatarg(args, 6, 4, &arg5))
4973 return NULL;
4974 if (!getifloatarg(args, 6, 5, &arg6))
4975 return NULL;
4976 window( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 );
4977 Py_INCREF(Py_None);
4978 return Py_None;
[2]4979}
4980
4981/* void lookat float s float s float s float s float s float s short s */
4982
4983static PyObject *
4984gl_lookat(PyObject *self, PyObject *args)
4985{
[391]4986 float arg1 ;
4987 float arg2 ;
4988 float arg3 ;
4989 float arg4 ;
4990 float arg5 ;
4991 float arg6 ;
4992 short arg7 ;
4993 if (!getifloatarg(args, 7, 0, &arg1))
4994 return NULL;
4995 if (!getifloatarg(args, 7, 1, &arg2))
4996 return NULL;
4997 if (!getifloatarg(args, 7, 2, &arg3))
4998 return NULL;
4999 if (!getifloatarg(args, 7, 3, &arg4))
5000 return NULL;
5001 if (!getifloatarg(args, 7, 4, &arg5))
5002 return NULL;
5003 if (!getifloatarg(args, 7, 5, &arg6))
5004 return NULL;
5005 if (!getishortarg(args, 7, 6, &arg7))
5006 return NULL;
5007 lookat( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 );
5008 Py_INCREF(Py_None);
5009 return Py_None;
[2]5010}
5011
5012/* void perspective short s float s float s float s */
5013
5014static PyObject *
5015gl_perspective(PyObject *self, PyObject *args)
5016{
[391]5017 short arg1 ;
5018 float arg2 ;
5019 float arg3 ;
5020 float arg4 ;
5021 if (!getishortarg(args, 4, 0, &arg1))
5022 return NULL;
5023 if (!getifloatarg(args, 4, 1, &arg2))
5024 return NULL;
5025 if (!getifloatarg(args, 4, 2, &arg3))
5026 return NULL;
5027 if (!getifloatarg(args, 4, 3, &arg4))
5028 return NULL;
5029 perspective( arg1 , arg2 , arg3 , arg4 );
5030 Py_INCREF(Py_None);
5031 return Py_None;
[2]5032}
5033
5034/* void polarview float s short s short s short s */
5035
5036static PyObject *
5037gl_polarview(PyObject *self, PyObject *args)
5038{
[391]5039 float arg1 ;
5040 short arg2 ;
5041 short arg3 ;
5042 short arg4 ;
5043 if (!getifloatarg(args, 4, 0, &arg1))
5044 return NULL;
5045 if (!getishortarg(args, 4, 1, &arg2))
5046 return NULL;
5047 if (!getishortarg(args, 4, 2, &arg3))
5048 return NULL;
5049 if (!getishortarg(args, 4, 3, &arg4))
5050 return NULL;
5051 polarview( arg1 , arg2 , arg3 , arg4 );
5052 Py_INCREF(Py_None);
5053 return Py_None;
[2]5054}
5055
5056/* void arcfs short s short s short s short s short s */
5057
5058static PyObject *
5059gl_arcfs(PyObject *self, PyObject *args)
5060{
[391]5061 short arg1 ;
5062 short arg2 ;
5063 short arg3 ;
5064 short arg4 ;
5065 short arg5 ;
5066 if (!getishortarg(args, 5, 0, &arg1))
5067 return NULL;
5068 if (!getishortarg(args, 5, 1, &arg2))
5069 return NULL;
5070 if (!getishortarg(args, 5, 2, &arg3))
5071 return NULL;
5072 if (!getishortarg(args, 5, 3, &arg4))
5073 return NULL;
5074 if (!getishortarg(args, 5, 4, &arg5))
5075 return NULL;
5076 arcfs( arg1 , arg2 , arg3 , arg4 , arg5 );
5077 Py_INCREF(Py_None);
5078 return Py_None;
[2]5079}
5080
5081/* void arcs short s short s short s short s short s */
5082
5083static PyObject *
5084gl_arcs(PyObject *self, PyObject *args)
5085{
[391]5086 short arg1 ;
5087 short arg2 ;
5088 short arg3 ;
5089 short arg4 ;
5090 short arg5 ;
5091 if (!getishortarg(args, 5, 0, &arg1))
5092 return NULL;
5093 if (!getishortarg(args, 5, 1, &arg2))
5094 return NULL;
5095 if (!getishortarg(args, 5, 2, &arg3))
5096 return NULL;
5097 if (!getishortarg(args, 5, 3, &arg4))
5098 return NULL;
5099 if (!getishortarg(args, 5, 4, &arg5))
5100 return NULL;
5101 arcs( arg1 , arg2 , arg3 , arg4 , arg5 );
5102 Py_INCREF(Py_None);
5103 return Py_None;
[2]5104}
5105
5106/* void rectcopy short s short s short s short s short s short s */
5107
5108static PyObject *
5109gl_rectcopy(PyObject *self, PyObject *args)
5110{
[391]5111 short arg1 ;
5112 short arg2 ;
5113 short arg3 ;
5114 short arg4 ;
5115 short arg5 ;
5116 short arg6 ;
5117 if (!getishortarg(args, 6, 0, &arg1))
5118 return NULL;
5119 if (!getishortarg(args, 6, 1, &arg2))
5120 return NULL;
5121 if (!getishortarg(args, 6, 2, &arg3))
5122 return NULL;
5123 if (!getishortarg(args, 6, 3, &arg4))
5124 return NULL;
5125 if (!getishortarg(args, 6, 4, &arg5))
5126 return NULL;
5127 if (!getishortarg(args, 6, 5, &arg6))
5128 return NULL;
5129 rectcopy( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 );
5130 Py_INCREF(Py_None);
5131 return Py_None;
[2]5132}
5133
5134/* void RGBcursor short s short s short s short s short s short s short s */
5135
5136static PyObject *
5137gl_RGBcursor(PyObject *self, PyObject *args)
5138{
[391]5139 short arg1 ;
5140 short arg2 ;
5141 short arg3 ;
5142 short arg4 ;
5143 short arg5 ;
5144 short arg6 ;
5145 short arg7 ;
5146 if (!getishortarg(args, 7, 0, &arg1))
5147 return NULL;
5148 if (!getishortarg(args, 7, 1, &arg2))
5149 return NULL;
5150 if (!getishortarg(args, 7, 2, &arg3))
5151 return NULL;
5152 if (!getishortarg(args, 7, 3, &arg4))
5153 return NULL;
5154 if (!getishortarg(args, 7, 4, &arg5))
5155 return NULL;
5156 if (!getishortarg(args, 7, 5, &arg6))
5157 return NULL;
5158 if (!getishortarg(args, 7, 6, &arg7))
5159 return NULL;
5160 RGBcursor( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 );
5161 Py_INCREF(Py_None);
5162 return Py_None;
[2]5163}
5164
5165/* long getbutton short s */
5166
5167static PyObject *
5168gl_getbutton(PyObject *self, PyObject *args)
5169{
[391]5170 long retval;
5171 short arg1 ;
5172 if (!getishortarg(args, 1, 0, &arg1))
5173 return NULL;
5174 retval = getbutton( arg1 );
5175 return mknewlongobject(retval);
[2]5176}
5177
5178/* long getcmmode */
5179
5180static PyObject *
5181gl_getcmmode(PyObject *self, PyObject *args)
5182{
[391]5183 long retval;
5184 retval = getcmmode( );
5185 return mknewlongobject(retval);
[2]5186}
5187
5188/* long getlsbackup */
5189
5190static PyObject *
5191gl_getlsbackup(PyObject *self, PyObject *args)
5192{
[391]5193 long retval;
5194 retval = getlsbackup( );
5195 return mknewlongobject(retval);
[2]5196}
5197
5198/* long getresetls */
5199
5200static PyObject *
5201gl_getresetls(PyObject *self, PyObject *args)
5202{
[391]5203 long retval;
5204 retval = getresetls( );
5205 return mknewlongobject(retval);
[2]5206}
5207
5208/* long getdcm */
5209
5210static PyObject *
5211gl_getdcm(PyObject *self, PyObject *args)
5212{
[391]5213 long retval;
5214 retval = getdcm( );
5215 return mknewlongobject(retval);
[2]5216}
5217
5218/* long getzbuffer */
5219
5220static PyObject *
5221gl_getzbuffer(PyObject *self, PyObject *args)
5222{
[391]5223 long retval;
5224 retval = getzbuffer( );
5225 return mknewlongobject(retval);
[2]5226}
5227
5228/* long ismex */
5229
5230static PyObject *
5231gl_ismex(PyObject *self, PyObject *args)
5232{
[391]5233 long retval;
5234 retval = ismex( );
5235 return mknewlongobject(retval);
[2]5236}
5237
5238/* long isobj long s */
5239
5240static PyObject *
5241gl_isobj(PyObject *self, PyObject *args)
5242{
[391]5243 long retval;
5244 long arg1 ;
5245 if (!getilongarg(args, 1, 0, &arg1))
5246 return NULL;
5247 retval = isobj( arg1 );
5248 return mknewlongobject(retval);
[2]5249}
5250
5251/* long isqueued short s */
5252
5253static PyObject *
5254gl_isqueued(PyObject *self, PyObject *args)
5255{
[391]5256 long retval;
5257 short arg1 ;
5258 if (!getishortarg(args, 1, 0, &arg1))
5259 return NULL;
5260 retval = isqueued( arg1 );
5261 return mknewlongobject(retval);
[2]5262}
5263
5264/* long istag long s */
5265
5266static PyObject *
5267gl_istag(PyObject *self, PyObject *args)
5268{
[391]5269 long retval;
5270 long arg1 ;
5271 if (!getilongarg(args, 1, 0, &arg1))
5272 return NULL;
5273 retval = istag( arg1 );
5274 return mknewlongobject(retval);
[2]5275}
5276
5277/* long genobj */
5278
5279static PyObject *
5280gl_genobj(PyObject *self, PyObject *args)
5281{
[391]5282 long retval;
5283 retval = genobj( );
5284 return mknewlongobject(retval);
[2]5285}
5286
5287/* long gentag */
5288
5289static PyObject *
5290gl_gentag(PyObject *self, PyObject *args)
5291{
[391]5292 long retval;
5293 retval = gentag( );
5294 return mknewlongobject(retval);
[2]5295}
5296
5297/* long getbuffer */
5298
5299static PyObject *
5300gl_getbuffer(PyObject *self, PyObject *args)
5301{
[391]5302 long retval;
5303 retval = getbuffer( );
5304 return mknewlongobject(retval);
[2]5305}
5306
5307/* long getcolor */
5308
5309static PyObject *
5310gl_getcolor(PyObject *self, PyObject *args)
5311{
[391]5312 long retval;
5313 retval = getcolor( );
5314 return mknewlongobject(retval);
[2]5315}
5316
5317/* long getdisplaymode */
5318
5319static PyObject *
5320gl_getdisplaymode(PyObject *self, PyObject *args)
5321{
[391]5322 long retval;
5323 retval = getdisplaymode( );
5324 return mknewlongobject(retval);
[2]5325}
5326
5327/* long getfont */
5328
5329static PyObject *
5330gl_getfont(PyObject *self, PyObject *args)
5331{
[391]5332 long retval;
5333 retval = getfont( );
5334 return mknewlongobject(retval);
[2]5335}
5336
5337/* long getheight */
5338
5339static PyObject *
5340gl_getheight(PyObject *self, PyObject *args)
5341{
[391]5342 long retval;
5343 retval = getheight( );
5344 return mknewlongobject(retval);
[2]5345}
5346
5347/* long gethitcode */
5348
5349static PyObject *
5350gl_gethitcode(PyObject *self, PyObject *args)
5351{
[391]5352 long retval;
5353 retval = gethitcode( );
5354 return mknewlongobject(retval);
[2]5355}
5356
5357/* long getlstyle */
5358
5359static PyObject *
5360gl_getlstyle(PyObject *self, PyObject *args)
5361{
[391]5362 long retval;
5363 retval = getlstyle( );
5364 return mknewlongobject(retval);
[2]5365}
5366
5367/* long getlwidth */
5368
5369static PyObject *
5370gl_getlwidth(PyObject *self, PyObject *args)
5371{
[391]5372 long retval;
5373 retval = getlwidth( );
5374 return mknewlongobject(retval);
[2]5375}
5376
5377/* long getmap */
5378
5379static PyObject *
5380gl_getmap(PyObject *self, PyObject *args)
5381{
[391]5382 long retval;
5383 retval = getmap( );
5384 return mknewlongobject(retval);
[2]5385}
5386
5387/* long getplanes */
5388
5389static PyObject *
5390gl_getplanes(PyObject *self, PyObject *args)
5391{
[391]5392 long retval;
5393 retval = getplanes( );
5394 return mknewlongobject(retval);
[2]5395}
5396
5397/* long getwritemask */
5398
5399static PyObject *
5400gl_getwritemask(PyObject *self, PyObject *args)
5401{
[391]5402 long retval;
5403 retval = getwritemask( );
5404 return mknewlongobject(retval);
[2]5405}
5406
5407/* long qtest */
5408
5409static PyObject *
5410gl_qtest(PyObject *self, PyObject *args)
5411{
[391]5412 long retval;
5413 retval = qtest( );
5414 return mknewlongobject(retval);
[2]5415}
5416
5417/* long getlsrepeat */
5418
5419static PyObject *
5420gl_getlsrepeat(PyObject *self, PyObject *args)
5421{
[391]5422 long retval;
5423 retval = getlsrepeat( );
5424 return mknewlongobject(retval);
[2]5425}
5426
5427/* long getmonitor */
5428
5429static PyObject *
5430gl_getmonitor(PyObject *self, PyObject *args)
5431{
[391]5432 long retval;
5433 retval = getmonitor( );
5434 return mknewlongobject(retval);
[2]5435}
5436
5437/* long getopenobj */
5438
5439static PyObject *
5440gl_getopenobj(PyObject *self, PyObject *args)
5441{
[391]5442 long retval;
5443 retval = getopenobj( );
5444 return mknewlongobject(retval);
[2]5445}
5446
5447/* long getpattern */
5448
5449static PyObject *
5450gl_getpattern(PyObject *self, PyObject *args)
5451{
[391]5452 long retval;
5453 retval = getpattern( );
5454 return mknewlongobject(retval);
[2]5455}
5456
5457/* long winget */
5458
5459static PyObject *
5460gl_winget(PyObject *self, PyObject *args)
5461{
[391]5462 long retval;
5463 retval = winget( );
5464 return mknewlongobject(retval);
[2]5465}
5466
5467/* long winattach */
5468
5469static PyObject *
5470gl_winattach(PyObject *self, PyObject *args)
5471{
[391]5472 long retval;
5473 retval = winattach( );
5474 return mknewlongobject(retval);
[2]5475}
5476
5477/* long getothermonitor */
5478
5479static PyObject *
5480gl_getothermonitor(PyObject *self, PyObject *args)
5481{
[391]5482 long retval;
5483 retval = getothermonitor( );
5484 return mknewlongobject(retval);
[2]5485}
5486
5487/* long newpup */
5488
5489static PyObject *
5490gl_newpup(PyObject *self, PyObject *args)
5491{
[391]5492 long retval;
5493 retval = newpup( );
5494 return mknewlongobject(retval);
[2]5495}
5496
5497/* long getvaluator short s */
5498
5499static PyObject *
5500gl_getvaluator(PyObject *self, PyObject *args)
5501{
[391]5502 long retval;
5503 short arg1 ;
5504 if (!getishortarg(args, 1, 0, &arg1))
5505 return NULL;
5506 retval = getvaluator( arg1 );
5507 return mknewlongobject(retval);
[2]5508}
5509
5510/* void winset long s */
5511
5512static PyObject *
5513gl_winset(PyObject *self, PyObject *args)
5514{
[391]5515 long arg1 ;
5516 if (!getilongarg(args, 1, 0, &arg1))
5517 return NULL;
5518 winset( arg1 );
5519 Py_INCREF(Py_None);
5520 return Py_None;
[2]5521}
5522
5523/* long dopup long s */
5524
5525static PyObject *
5526gl_dopup(PyObject *self, PyObject *args)
5527{
[391]5528 long retval;
5529 long arg1 ;
5530 if (!getilongarg(args, 1, 0, &arg1))
5531 return NULL;
5532 retval = dopup( arg1 );
5533 return mknewlongobject(retval);
[2]5534}
5535
5536/* void getdepth short r short r */
5537
5538static PyObject *
5539gl_getdepth(PyObject *self, PyObject *args)
5540{
[391]5541 short arg1 ;
5542 short arg2 ;
5543 getdepth( & arg1 , & arg2 );
5544 { PyObject *v = PyTuple_New( 2 );
5545 if (v == NULL) return NULL;
5546 PyTuple_SetItem(v, 0, mknewshortobject(arg1));
5547 PyTuple_SetItem(v, 1, mknewshortobject(arg2));
5548 return v;
5549 }
[2]5550}
5551
5552/* void getcpos short r short r */
5553
5554static PyObject *
5555gl_getcpos(PyObject *self, PyObject *args)
5556{
[391]5557 short arg1 ;
5558 short arg2 ;
5559 getcpos( & arg1 , & arg2 );
5560 { PyObject *v = PyTuple_New( 2 );
5561 if (v == NULL) return NULL;
5562 PyTuple_SetItem(v, 0, mknewshortobject(arg1));
5563 PyTuple_SetItem(v, 1, mknewshortobject(arg2));
5564 return v;
5565 }
[2]5566}
5567
5568/* void getsize long r long r */
5569
5570static PyObject *
5571gl_getsize(PyObject *self, PyObject *args)
5572{
[391]5573 long arg1 ;
5574 long arg2 ;
5575 getsize( & arg1 , & arg2 );
5576 { PyObject *v = PyTuple_New( 2 );
5577 if (v == NULL) return NULL;
5578 PyTuple_SetItem(v, 0, mknewlongobject(arg1));
5579 PyTuple_SetItem(v, 1, mknewlongobject(arg2));
5580 return v;
5581 }
[2]5582}
5583
5584/* void getorigin long r long r */
5585
5586static PyObject *
5587gl_getorigin(PyObject *self, PyObject *args)
5588{
[391]5589 long arg1 ;
5590 long arg2 ;
5591 getorigin( & arg1 , & arg2 );
5592 { PyObject *v = PyTuple_New( 2 );
5593 if (v == NULL) return NULL;
5594 PyTuple_SetItem(v, 0, mknewlongobject(arg1));
5595 PyTuple_SetItem(v, 1, mknewlongobject(arg2));
5596 return v;
5597 }
[2]5598}
5599
5600/* void getviewport short r short r short r short r */
5601
5602static PyObject *
5603gl_getviewport(PyObject *self, PyObject *args)
5604{
[391]5605 short arg1 ;
5606 short arg2 ;
5607 short arg3 ;
5608 short arg4 ;
5609 getviewport( & arg1 , & arg2 , & arg3 , & arg4 );
5610 { PyObject *v = PyTuple_New( 4 );
5611 if (v == NULL) return NULL;
5612 PyTuple_SetItem(v, 0, mknewshortobject(arg1));
5613 PyTuple_SetItem(v, 1, mknewshortobject(arg2));
5614 PyTuple_SetItem(v, 2, mknewshortobject(arg3));
5615 PyTuple_SetItem(v, 3, mknewshortobject(arg4));
5616 return v;
5617 }
[2]5618}
5619
5620/* void gettp short r short r short r short r */
5621
5622static PyObject *
5623gl_gettp(PyObject *self, PyObject *args)
5624{
[391]5625 short arg1 ;
5626 short arg2 ;
5627 short arg3 ;
5628 short arg4 ;
5629 gettp( & arg1 , & arg2 , & arg3 , & arg4 );
5630 { PyObject *v = PyTuple_New( 4 );
5631 if (v == NULL) return NULL;
5632 PyTuple_SetItem(v, 0, mknewshortobject(arg1));
5633 PyTuple_SetItem(v, 1, mknewshortobject(arg2));
5634 PyTuple_SetItem(v, 2, mknewshortobject(arg3));
5635 PyTuple_SetItem(v, 3, mknewshortobject(arg4));
5636 return v;
5637 }
[2]5638}
5639
5640/* void getgpos float r float r float r float r */
5641
5642static PyObject *
5643gl_getgpos(PyObject *self, PyObject *args)
5644{
[391]5645 float arg1 ;
5646 float arg2 ;
5647 float arg3 ;
5648 float arg4 ;
5649 getgpos( & arg1 , & arg2 , & arg3 , & arg4 );
5650 { PyObject *v = PyTuple_New( 4 );
5651 if (v == NULL) return NULL;
5652 PyTuple_SetItem(v, 0, mknewfloatobject(arg1));
5653 PyTuple_SetItem(v, 1, mknewfloatobject(arg2));
5654 PyTuple_SetItem(v, 2, mknewfloatobject(arg3));
5655 PyTuple_SetItem(v, 3, mknewfloatobject(arg4));
5656 return v;
5657 }
[2]5658}
5659
5660/* void winposition long s long s long s long s */
5661
5662static PyObject *
5663gl_winposition(PyObject *self, PyObject *args)
5664{
[391]5665 long arg1 ;
5666 long arg2 ;
5667 long arg3 ;
5668 long arg4 ;
5669 if (!getilongarg(args, 4, 0, &arg1))
5670 return NULL;
5671 if (!getilongarg(args, 4, 1, &arg2))
5672 return NULL;
5673 if (!getilongarg(args, 4, 2, &arg3))
5674 return NULL;
5675 if (!getilongarg(args, 4, 3, &arg4))
5676 return NULL;
5677 winposition( arg1 , arg2 , arg3 , arg4 );
5678 Py_INCREF(Py_None);
5679 return Py_None;
[2]5680}
5681
5682/* void gRGBcolor short r short r short r */
5683
5684static PyObject *
5685gl_gRGBcolor(PyObject *self, PyObject *args)
5686{
[391]5687 short arg1 ;
5688 short arg2 ;
5689 short arg3 ;
5690 gRGBcolor( & arg1 , & arg2 , & arg3 );
5691 { PyObject *v = PyTuple_New( 3 );
5692 if (v == NULL) return NULL;
5693 PyTuple_SetItem(v, 0, mknewshortobject(arg1));
5694 PyTuple_SetItem(v, 1, mknewshortobject(arg2));
5695 PyTuple_SetItem(v, 2, mknewshortobject(arg3));
5696 return v;
5697 }
[2]5698}
5699
5700/* void gRGBmask short r short r short r */
5701
5702static PyObject *
5703gl_gRGBmask(PyObject *self, PyObject *args)
5704{
[391]5705 short arg1 ;
5706 short arg2 ;
5707 short arg3 ;
5708 gRGBmask( & arg1 , & arg2 , & arg3 );
5709 { PyObject *v = PyTuple_New( 3 );
5710 if (v == NULL) return NULL;
5711 PyTuple_SetItem(v, 0, mknewshortobject(arg1));
5712 PyTuple_SetItem(v, 1, mknewshortobject(arg2));
5713 PyTuple_SetItem(v, 2, mknewshortobject(arg3));
5714 return v;
5715 }
[2]5716}
5717
5718/* void getscrmask short r short r short r short r */
5719
5720static PyObject *
5721gl_getscrmask(PyObject *self, PyObject *args)
5722{
[391]5723 short arg1 ;
5724 short arg2 ;
5725 short arg3 ;
5726 short arg4 ;
5727 getscrmask( & arg1 , & arg2 , & arg3 , & arg4 );
5728 { PyObject *v = PyTuple_New( 4 );
5729 if (v == NULL) return NULL;
5730 PyTuple_SetItem(v, 0, mknewshortobject(arg1));
5731 PyTuple_SetItem(v, 1, mknewshortobject(arg2));
5732 PyTuple_SetItem(v, 2, mknewshortobject(arg3));
5733 PyTuple_SetItem(v, 3, mknewshortobject(arg4));
5734 return v;
5735 }
[2]5736}
5737
5738/* void getmcolor short s short r short r short r */
5739
5740static PyObject *
5741gl_getmcolor(PyObject *self, PyObject *args)
5742{
[391]5743 short arg1 ;
5744 short arg2 ;
5745 short arg3 ;
5746 short arg4 ;
5747 if (!getishortarg(args, 1, 0, &arg1))
5748 return NULL;
5749 getmcolor( arg1 , & arg2 , & arg3 , & arg4 );
5750 { PyObject *v = PyTuple_New( 3 );
5751 if (v == NULL) return NULL;
5752 PyTuple_SetItem(v, 0, mknewshortobject(arg2));
5753 PyTuple_SetItem(v, 1, mknewshortobject(arg3));
5754 PyTuple_SetItem(v, 2, mknewshortobject(arg4));
5755 return v;
5756 }
[2]5757}
5758
5759/* void mapw long s short s short s float r float r float r float r float r float r */
5760
5761static PyObject *
5762gl_mapw(PyObject *self, PyObject *args)
5763{
[391]5764 long arg1 ;
5765 short arg2 ;
5766 short arg3 ;
5767 float arg4 ;
5768 float arg5 ;
5769 float arg6 ;
5770 float arg7 ;
5771 float arg8 ;
5772 float arg9 ;
5773 if (!getilongarg(args, 3, 0, &arg1))
5774 return NULL;
5775 if (!getishortarg(args, 3, 1, &arg2))
5776 return NULL;
5777 if (!getishortarg(args, 3, 2, &arg3))
5778 return NULL;
5779 mapw( arg1 , arg2 , arg3 , & arg4 , & arg5 , & arg6 , & arg7 , & arg8 , & arg9 );
5780 { PyObject *v = PyTuple_New( 6 );
5781 if (v == NULL) return NULL;
5782 PyTuple_SetItem(v, 0, mknewfloatobject(arg4));
5783 PyTuple_SetItem(v, 1, mknewfloatobject(arg5));
5784 PyTuple_SetItem(v, 2, mknewfloatobject(arg6));
5785 PyTuple_SetItem(v, 3, mknewfloatobject(arg7));
5786 PyTuple_SetItem(v, 4, mknewfloatobject(arg8));
5787 PyTuple_SetItem(v, 5, mknewfloatobject(arg9));
5788 return v;
5789 }
[2]5790}
5791
5792/* void mapw2 long s short s short s float r float r */
5793
5794static PyObject *
5795gl_mapw2(PyObject *self, PyObject *args)
5796{
[391]5797 long arg1 ;
5798 short arg2 ;
5799 short arg3 ;
5800 float arg4 ;
5801 float arg5 ;
5802 if (!getilongarg(args, 3, 0, &arg1))
5803 return NULL;
5804 if (!getishortarg(args, 3, 1, &arg2))
5805 return NULL;
5806 if (!getishortarg(args, 3, 2, &arg3))
5807 return NULL;
5808 mapw2( arg1 , arg2 , arg3 , & arg4 , & arg5 );
5809 { PyObject *v = PyTuple_New( 2 );
5810 if (v == NULL) return NULL;
5811 PyTuple_SetItem(v, 0, mknewfloatobject(arg4));
5812 PyTuple_SetItem(v, 1, mknewfloatobject(arg5));
5813 return v;
5814 }
[2]5815}
5816
5817/* void getcursor short r u_short r u_short r long r */
5818
5819static PyObject *
5820gl_getcursor(PyObject *self, PyObject *args)
5821{
[391]5822 short arg1 ;
5823 unsigned short arg2 ;
5824 unsigned short arg3 ;
5825 long arg4 ;
5826 getcursor( & arg1 , & arg2 , & arg3 , & arg4 );
5827 { PyObject *v = PyTuple_New( 4 );
5828 if (v == NULL) return NULL;
5829 PyTuple_SetItem(v, 0, mknewshortobject(arg1));
5830 PyTuple_SetItem(v, 1, mknewshortobject((short) arg2));
5831 PyTuple_SetItem(v, 2, mknewshortobject((short) arg3));
5832 PyTuple_SetItem(v, 3, mknewlongobject(arg4));
5833 return v;
5834 }
[2]5835}
5836
5837/* void cmode */
5838
5839static PyObject *
5840gl_cmode(PyObject *self, PyObject *args)
5841{
[391]5842 cmode( );
5843 Py_INCREF(Py_None);
5844 return Py_None;
[2]5845}
5846
5847/* void concave long s */
5848
5849static PyObject *
5850gl_concave(PyObject *self, PyObject *args)
5851{
[391]5852 long arg1 ;
5853 if (!getilongarg(args, 1, 0, &arg1))
5854 return NULL;
5855 concave( arg1 );
5856 Py_INCREF(Py_None);
5857 return Py_None;
[2]5858}
5859
5860/* void curstype long s */
5861
5862static PyObject *
5863gl_curstype(PyObject *self, PyObject *args)
5864{
[391]5865 long arg1 ;
5866 if (!getilongarg(args, 1, 0, &arg1))
5867 return NULL;
5868 curstype( arg1 );
5869 Py_INCREF(Py_None);
5870 return Py_None;
[2]5871}
5872
5873/* void drawmode long s */
5874
5875static PyObject *
5876gl_drawmode(PyObject *self, PyObject *args)
5877{
[391]5878 long arg1 ;
5879 if (!getilongarg(args, 1, 0, &arg1))
5880 return NULL;
5881 drawmode( arg1 );
5882 Py_INCREF(Py_None);
5883 return Py_None;
[2]5884}
5885
5886/* void gammaramp short s[256] short s[256] short s[256] */
5887
5888static PyObject *
5889gl_gammaramp(PyObject *self, PyObject *args)
5890{
[391]5891 short arg1 [ 256 ] ;
5892 short arg2 [ 256 ] ;
5893 short arg3 [ 256 ] ;
5894 if (!getishortarray(args, 3, 0, 256 , arg1))
5895 return NULL;
5896 if (!getishortarray(args, 3, 1, 256 , arg2))
5897 return NULL;
5898 if (!getishortarray(args, 3, 2, 256 , arg3))
5899 return NULL;
5900 gammaramp( arg1 , arg2 , arg3 );
5901 Py_INCREF(Py_None);
5902 return Py_None;
[2]5903}
5904
5905/* long getbackface */
5906
5907static PyObject *
5908gl_getbackface(PyObject *self, PyObject *args)
5909{
[391]5910 long retval;
5911 retval = getbackface( );
5912 return mknewlongobject(retval);
[2]5913}
5914
5915/* long getdescender */
5916
5917static PyObject *
5918gl_getdescender(PyObject *self, PyObject *args)
5919{
[391]5920 long retval;
5921 retval = getdescender( );
5922 return mknewlongobject(retval);
[2]5923}
5924
5925/* long getdrawmode */
5926
5927static PyObject *
5928gl_getdrawmode(PyObject *self, PyObject *args)
5929{
[391]5930 long retval;
5931 retval = getdrawmode( );
5932 return mknewlongobject(retval);
[2]5933}
5934
5935/* long getmmode */
5936
5937static PyObject *
5938gl_getmmode(PyObject *self, PyObject *args)
5939{
[391]5940 long retval;
5941 retval = getmmode( );
5942 return mknewlongobject(retval);
[2]5943}
5944
5945/* long getsm */
5946
5947static PyObject *
5948gl_getsm(PyObject *self, PyObject *args)
5949{
[391]5950 long retval;
5951 retval = getsm( );
5952 return mknewlongobject(retval);
[2]5953}
5954
5955/* long getvideo long s */
5956
5957static PyObject *
5958gl_getvideo(PyObject *self, PyObject *args)
5959{
[391]5960 long retval;
5961 long arg1 ;
5962 if (!getilongarg(args, 1, 0, &arg1))
5963 return NULL;
5964 retval = getvideo( arg1 );
5965 return mknewlongobject(retval);
[2]5966}
5967
5968/* void imakebackground */
5969
5970static PyObject *
5971gl_imakebackground(PyObject *self, PyObject *args)
5972{
[391]5973 imakebackground( );
5974 Py_INCREF(Py_None);
5975 return Py_None;
[2]5976}
5977
5978/* void lmbind short s short s */
5979
5980static PyObject *
5981gl_lmbind(PyObject *self, PyObject *args)
5982{
[391]5983 short arg1 ;
5984 short arg2 ;
5985 if (!getishortarg(args, 2, 0, &arg1))
5986 return NULL;
5987 if (!getishortarg(args, 2, 1, &arg2))
5988 return NULL;
5989 lmbind( arg1 , arg2 );
5990 Py_INCREF(Py_None);
5991 return Py_None;
[2]5992}
5993
5994/* void lmdef long s long s long s float s[arg3] */
5995
5996static PyObject *
5997gl_lmdef(PyObject *self, PyObject *args)
5998{
[391]5999 long arg1 ;
6000 long arg2 ;
6001 long arg3 ;
6002 float * arg4 ;
6003 if (!getilongarg(args, 3, 0, &arg1))
6004 return NULL;
6005 if (!getilongarg(args, 3, 1, &arg2))
6006 return NULL;
6007 if (!getilongarraysize(args, 3, 2, &arg3))
6008 return NULL;
6009 if ((arg4 = PyMem_NEW(float , arg3 )) == NULL)
6010 return PyErr_NoMemory();
6011 if (!getifloatarray(args, 3, 2, arg3 , arg4))
6012 return NULL;
6013 lmdef( arg1 , arg2 , arg3 , arg4 );
6014 PyMem_DEL(arg4);
6015 Py_INCREF(Py_None);
6016 return Py_None;
[2]6017}
6018
6019/* void mmode long s */
6020
6021static PyObject *
6022gl_mmode(PyObject *self, PyObject *args)
6023{
[391]6024 long arg1 ;
6025 if (!getilongarg(args, 1, 0, &arg1))
6026 return NULL;
6027 mmode( arg1 );
6028 Py_INCREF(Py_None);
6029 return Py_None;
[2]6030}
6031
6032/* void normal float s[3] */
6033
6034static PyObject *
6035gl_normal(PyObject *self, PyObject *args)
6036{
[391]6037 float arg1 [ 3 ] ;
6038 if (!getifloatarray(args, 1, 0, 3 , arg1))
6039 return NULL;
6040 normal( arg1 );
6041 Py_INCREF(Py_None);
6042 return Py_None;
[2]6043}
6044
6045/* void overlay long s */
6046
6047static PyObject *
6048gl_overlay(PyObject *self, PyObject *args)
6049{
[391]6050 long arg1 ;
6051 if (!getilongarg(args, 1, 0, &arg1))
6052 return NULL;
6053 overlay( arg1 );
6054 Py_INCREF(Py_None);
6055 return Py_None;
[2]6056}
6057
6058/* void RGBrange short s short s short s short s short s short s short s short s */
6059
6060static PyObject *
6061gl_RGBrange(PyObject *self, PyObject *args)
6062{
[391]6063 short arg1 ;
6064 short arg2 ;
6065 short arg3 ;
6066 short arg4 ;
6067 short arg5 ;
6068 short arg6 ;
6069 short arg7 ;
6070 short arg8 ;
6071 if (!getishortarg(args, 8, 0, &arg1))
6072 return NULL;
6073 if (!getishortarg(args, 8, 1, &arg2))
6074 return NULL;
6075 if (!getishortarg(args, 8, 2, &arg3))
6076 return NULL;
6077 if (!getishortarg(args, 8, 3, &arg4))
6078 return NULL;
6079 if (!getishortarg(args, 8, 4, &arg5))
6080 return NULL;
6081 if (!getishortarg(args, 8, 5, &arg6))
6082 return NULL;
6083 if (!getishortarg(args, 8, 6, &arg7))
6084 return NULL;
6085 if (!getishortarg(args, 8, 7, &arg8))
6086 return NULL;
6087 RGBrange( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 );
6088 Py_INCREF(Py_None);
6089 return Py_None;
[2]6090}
6091
6092/* void setvideo long s long s */
6093
6094static PyObject *
6095gl_setvideo(PyObject *self, PyObject *args)
6096{
[391]6097 long arg1 ;
6098 long arg2 ;
6099 if (!getilongarg(args, 2, 0, &arg1))
6100 return NULL;
6101 if (!getilongarg(args, 2, 1, &arg2))
6102 return NULL;
6103 setvideo( arg1 , arg2 );
6104 Py_INCREF(Py_None);
6105 return Py_None;
[2]6106}
6107
6108/* void shademodel long s */
6109
6110static PyObject *
6111gl_shademodel(PyObject *self, PyObject *args)
6112{
[391]6113 long arg1 ;
6114 if (!getilongarg(args, 1, 0, &arg1))
6115 return NULL;
6116 shademodel( arg1 );
6117 Py_INCREF(Py_None);
6118 return Py_None;
[2]6119}
6120
6121/* void underlay long s */
6122
6123static PyObject *
6124gl_underlay(PyObject *self, PyObject *args)
6125{
[391]6126 long arg1 ;
6127 if (!getilongarg(args, 1, 0, &arg1))
6128 return NULL;
6129 underlay( arg1 );
6130 Py_INCREF(Py_None);
6131 return Py_None;
[2]6132}
6133
6134/* void bgnclosedline */
6135
6136static PyObject *
6137gl_bgnclosedline(PyObject *self, PyObject *args)
6138{
[391]6139 bgnclosedline( );
6140 Py_INCREF(Py_None);
6141 return Py_None;
[2]6142}
6143
6144/* void bgnline */
6145
6146static PyObject *
6147gl_bgnline(PyObject *self, PyObject *args)
6148{
[391]6149 bgnline( );
6150 Py_INCREF(Py_None);
6151 return Py_None;
[2]6152}
6153
6154/* void bgnpoint */
6155
6156static PyObject *
6157gl_bgnpoint(PyObject *self, PyObject *args)
6158{
[391]6159 bgnpoint( );
6160 Py_INCREF(Py_None);
6161 return Py_None;
[2]6162}
6163
6164/* void bgnpolygon */
6165
6166static PyObject *
6167gl_bgnpolygon(PyObject *self, PyObject *args)
6168{
[391]6169 bgnpolygon( );
6170 Py_INCREF(Py_None);
6171 return Py_None;
[2]6172}
6173
6174/* void bgnsurface */
6175
6176static PyObject *
6177gl_bgnsurface(PyObject *self, PyObject *args)
6178{
[391]6179 bgnsurface( );
6180 Py_INCREF(Py_None);
6181 return Py_None;
[2]6182}
6183
6184/* void bgntmesh */
6185
6186static PyObject *
6187gl_bgntmesh(PyObject *self, PyObject *args)
6188{
[391]6189 bgntmesh( );
6190 Py_INCREF(Py_None);
6191 return Py_None;
[2]6192}
6193
6194/* void bgntrim */
6195
6196static PyObject *
6197gl_bgntrim(PyObject *self, PyObject *args)
6198{
[391]6199 bgntrim( );
6200 Py_INCREF(Py_None);
6201 return Py_None;
[2]6202}
6203
6204/* void endclosedline */
6205
6206static PyObject *
6207gl_endclosedline(PyObject *self, PyObject *args)
6208{
[391]6209 endclosedline( );
6210 Py_INCREF(Py_None);
6211 return Py_None;
[2]6212}
6213
6214/* void endline */
6215
6216static PyObject *
6217gl_endline(PyObject *self, PyObject *args)
6218{
[391]6219 endline( );
6220 Py_INCREF(Py_None);
6221 return Py_None;
[2]6222}
6223
6224/* void endpoint */
6225
6226static PyObject *
6227gl_endpoint(PyObject *self, PyObject *args)
6228{
[391]6229 endpoint( );
6230 Py_INCREF(Py_None);
6231 return Py_None;
[2]6232}
6233
6234/* void endpolygon */
6235
6236static PyObject *
6237gl_endpolygon(PyObject *self, PyObject *args)
6238{
[391]6239 endpolygon( );
6240 Py_INCREF(Py_None);
6241 return Py_None;
[2]6242}
6243
6244/* void endsurface */
6245
6246static PyObject *
6247gl_endsurface(PyObject *self, PyObject *args)
6248{
[391]6249 endsurface( );
6250 Py_INCREF(Py_None);
6251 return Py_None;
[2]6252}
6253
6254/* void endtmesh */
6255
6256static PyObject *
6257gl_endtmesh(PyObject *self, PyObject *args)
6258{
[391]6259 endtmesh( );
6260 Py_INCREF(Py_None);
6261 return Py_None;
[2]6262}
6263
6264/* void endtrim */
6265
6266static PyObject *
6267gl_endtrim(PyObject *self, PyObject *args)
6268{
[391]6269 endtrim( );
6270 Py_INCREF(Py_None);
6271 return Py_None;
[2]6272}
6273
6274/* void blendfunction long s long s */
6275
6276static PyObject *
6277gl_blendfunction(PyObject *self, PyObject *args)
6278{
[391]6279 long arg1 ;
6280 long arg2 ;
6281 if (!getilongarg(args, 2, 0, &arg1))
6282 return NULL;
6283 if (!getilongarg(args, 2, 1, &arg2))
6284 return NULL;
6285 blendfunction( arg1 , arg2 );
6286 Py_INCREF(Py_None);
6287 return Py_None;
[2]6288}
6289
6290/* void c3f float s[3] */
6291
6292static PyObject *
6293gl_c3f(PyObject *self, PyObject *args)
6294{
[391]6295 float arg1 [ 3 ] ;
6296 if (!getifloatarray(args, 1, 0, 3 , arg1))
6297 return NULL;
6298 c3f( arg1 );
6299 Py_INCREF(Py_None);
6300 return Py_None;
[2]6301}
6302
6303/* void c3i long s[3] */
6304
6305static PyObject *
6306gl_c3i(PyObject *self, PyObject *args)
6307{
[391]6308 long arg1 [ 3 ] ;
6309 if (!getilongarray(args, 1, 0, 3 , arg1))
6310 return NULL;
6311 c3i( arg1 );
6312 Py_INCREF(Py_None);
6313 return Py_None;
[2]6314}
6315
6316/* void c3s short s[3] */
6317
6318static PyObject *
6319gl_c3s(PyObject *self, PyObject *args)
6320{
[391]6321 short arg1 [ 3 ] ;
6322 if (!getishortarray(args, 1, 0, 3 , arg1))
6323 return NULL;
6324 c3s( arg1 );
6325 Py_INCREF(Py_None);
6326 return Py_None;
[2]6327}
6328
6329/* void c4f float s[4] */
6330
6331static PyObject *
6332gl_c4f(PyObject *self, PyObject *args)
6333{
[391]6334 float arg1 [ 4 ] ;
6335 if (!getifloatarray(args, 1, 0, 4 , arg1))
6336 return NULL;
6337 c4f( arg1 );
6338 Py_INCREF(Py_None);
6339 return Py_None;
[2]6340}
6341
6342/* void c4i long s[4] */
6343
6344static PyObject *
6345gl_c4i(PyObject *self, PyObject *args)
6346{
[391]6347 long arg1 [ 4 ] ;
6348 if (!getilongarray(args, 1, 0, 4 , arg1))
6349 return NULL;
6350 c4i( arg1 );
6351 Py_INCREF(Py_None);
6352 return Py_None;
[2]6353}
6354
6355/* void c4s short s[4] */
6356
6357static PyObject *
6358gl_c4s(PyObject *self, PyObject *args)
6359{
[391]6360 short arg1 [ 4 ] ;
6361 if (!getishortarray(args, 1, 0, 4 , arg1))
6362 return NULL;
6363 c4s( arg1 );
6364 Py_INCREF(Py_None);
6365 return Py_None;
[2]6366}
6367
6368/* void colorf float s */
6369
6370static PyObject *
6371gl_colorf(PyObject *self, PyObject *args)
6372{
[391]6373 float arg1 ;
6374 if (!getifloatarg(args, 1, 0, &arg1))
6375 return NULL;
6376 colorf( arg1 );
6377 Py_INCREF(Py_None);
6378 return Py_None;
[2]6379}
6380
6381/* void cpack long s */
6382
6383static PyObject *
6384gl_cpack(PyObject *self, PyObject *args)
6385{
[391]6386 long arg1 ;
6387 if (!getilongarg(args, 1, 0, &arg1))
6388 return NULL;
6389 cpack( arg1 );
6390 Py_INCREF(Py_None);
6391 return Py_None;
[2]6392}
6393
6394/* void czclear long s long s */
6395
6396static PyObject *
6397gl_czclear(PyObject *self, PyObject *args)
6398{
[391]6399 long arg1 ;
6400 long arg2 ;
6401 if (!getilongarg(args, 2, 0, &arg1))
6402 return NULL;
6403 if (!getilongarg(args, 2, 1, &arg2))
6404 return NULL;
6405 czclear( arg1 , arg2 );
6406 Py_INCREF(Py_None);
6407 return Py_None;
[2]6408}
6409
6410/* void dglclose long s */
6411
6412static PyObject *
6413gl_dglclose(PyObject *self, PyObject *args)
6414{
[391]6415 long arg1 ;
6416 if (!getilongarg(args, 1, 0, &arg1))
6417 return NULL;
6418 dglclose( arg1 );
6419 Py_INCREF(Py_None);
6420 return Py_None;
[2]6421}
6422
6423/* long dglopen char *s long s */
6424
6425static PyObject *
6426gl_dglopen(PyObject *self, PyObject *args)
6427{
[391]6428 long retval;
6429 string arg1 ;
6430 long arg2 ;
6431 if (!getistringarg(args, 2, 0, &arg1))
6432 return NULL;
6433 if (!getilongarg(args, 2, 1, &arg2))
6434 return NULL;
6435 retval = dglopen( arg1 , arg2 );
6436 return mknewlongobject(retval);
[2]6437}
6438
6439/* long getgdesc long s */
6440
6441static PyObject *
6442gl_getgdesc(PyObject *self, PyObject *args)
6443{
[391]6444 long retval;
6445 long arg1 ;
6446 if (!getilongarg(args, 1, 0, &arg1))
6447 return NULL;
6448 retval = getgdesc( arg1 );
6449 return mknewlongobject(retval);
[2]6450}
6451
6452/* void getnurbsproperty long s float r */
6453
6454static PyObject *
6455gl_getnurbsproperty(PyObject *self, PyObject *args)
6456{
[391]6457 long arg1 ;
6458 float arg2 ;
6459 if (!getilongarg(args, 1, 0, &arg1))
6460 return NULL;
6461 getnurbsproperty( arg1 , & arg2 );
6462 return mknewfloatobject(arg2);
[2]6463}
6464
6465/* void glcompat long s long s */
6466
6467static PyObject *
6468gl_glcompat(PyObject *self, PyObject *args)
6469{
[391]6470 long arg1 ;
6471 long arg2 ;
6472 if (!getilongarg(args, 2, 0, &arg1))
6473 return NULL;
6474 if (!getilongarg(args, 2, 1, &arg2))
6475 return NULL;
6476 glcompat( arg1 , arg2 );
6477 Py_INCREF(Py_None);
6478 return Py_None;
[2]6479}
6480
6481/* void iconsize long s long s */
6482
6483static PyObject *
6484gl_iconsize(PyObject *self, PyObject *args)
6485{
[391]6486 long arg1 ;
6487 long arg2 ;
6488 if (!getilongarg(args, 2, 0, &arg1))
6489 return NULL;
6490 if (!getilongarg(args, 2, 1, &arg2))
6491 return NULL;
6492 iconsize( arg1 , arg2 );
6493 Py_INCREF(Py_None);
6494 return Py_None;
[2]6495}
6496
6497/* void icontitle char *s */
6498
6499static PyObject *
6500gl_icontitle(PyObject *self, PyObject *args)
6501{
[391]6502 string arg1 ;
6503 if (!getistringarg(args, 1, 0, &arg1))
6504 return NULL;
6505 icontitle( arg1 );
6506 Py_INCREF(Py_None);
6507 return Py_None;
[2]6508}
6509
6510/* void lRGBrange short s short s short s short s short s short s long s long s */
6511
6512static PyObject *
6513gl_lRGBrange(PyObject *self, PyObject *args)
6514{
[391]6515 short arg1 ;
6516 short arg2 ;
6517 short arg3 ;
6518 short arg4 ;
6519 short arg5 ;
6520 short arg6 ;
6521 long arg7 ;
6522 long arg8 ;
6523 if (!getishortarg(args, 8, 0, &arg1))
6524 return NULL;
6525 if (!getishortarg(args, 8, 1, &arg2))
6526 return NULL;
6527 if (!getishortarg(args, 8, 2, &arg3))
6528 return NULL;
6529 if (!getishortarg(args, 8, 3, &arg4))
6530 return NULL;
6531 if (!getishortarg(args, 8, 4, &arg5))
6532 return NULL;
6533 if (!getishortarg(args, 8, 5, &arg6))
6534 return NULL;
6535 if (!getilongarg(args, 8, 6, &arg7))
6536 return NULL;
6537 if (!getilongarg(args, 8, 7, &arg8))
6538 return NULL;
6539 lRGBrange( arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 );
6540 Py_INCREF(Py_None);
6541 return Py_None;
[2]6542}
6543
6544/* void linesmooth long s */
6545
6546static PyObject *
6547gl_linesmooth(PyObject *self, PyObject *args)
6548{
[391]6549 long arg1 ;
6550 if (!getilongarg(args, 1, 0, &arg1))
6551 return NULL;
6552 linesmooth( arg1 );
6553 Py_INCREF(Py_None);
6554 return Py_None;
[2]6555}
6556
6557/* void lmcolor long s */
6558
6559static PyObject *
6560gl_lmcolor(PyObject *self, PyObject *args)
6561{
[391]6562 long arg1 ;
6563 if (!getilongarg(args, 1, 0, &arg1))
6564 return NULL;
6565 lmcolor( arg1 );
6566 Py_INCREF(Py_None);
6567 return Py_None;
[2]6568}
6569
6570/* void logicop long s */
6571
6572static PyObject *
6573gl_logicop(PyObject *self, PyObject *args)
6574{
[391]6575 long arg1 ;
6576 if (!getilongarg(args, 1, 0, &arg1))
6577 return NULL;
6578 logicop( arg1 );
6579 Py_INCREF(Py_None);
6580 return Py_None;
[2]6581}
6582
6583/* void lsetdepth long s long s */
6584
6585static PyObject *
6586gl_lsetdepth(PyObject *self, PyObject *args)
6587{
[391]6588 long arg1 ;
6589 long arg2 ;
6590 if (!getilongarg(args, 2, 0, &arg1))
6591 return NULL;
6592 if (!getilongarg(args, 2, 1, &arg2))
6593 return NULL;
6594 lsetdepth( arg1 , arg2 );
6595 Py_INCREF(Py_None);
6596 return Py_None;
[2]6597}
6598
6599/* void lshaderange short s short s long s long s */
6600
6601static PyObject *
6602gl_lshaderange(PyObject *self, PyObject *args)
6603{
[391]6604 short arg1 ;
6605 short arg2 ;
6606 long arg3 ;
6607 long arg4 ;
6608 if (!getishortarg(args, 4, 0, &arg1))
6609 return NULL;
6610 if (!getishortarg(args, 4, 1, &arg2))
6611 return NULL;
6612 if (!getilongarg(args, 4, 2, &arg3))
6613 return NULL;
6614 if (!getilongarg(args, 4, 3, &arg4))
6615 return NULL;
6616 lshaderange( arg1 , arg2 , arg3 , arg4 );
6617 Py_INCREF(Py_None);
6618 return Py_None;
[2]6619}
6620
6621/* void n3f float s[3] */
6622
6623static PyObject *
6624gl_n3f(PyObject *self, PyObject *args)
6625{
[391]6626 float arg1 [ 3 ] ;
6627 if (!getifloatarray(args, 1, 0, 3 , arg1))
6628 return NULL;
6629 n3f( arg1 );
6630 Py_INCREF(Py_None);
6631 return Py_None;
[2]6632}
6633
6634/* void noborder */
6635
6636static PyObject *
6637gl_noborder(PyObject *self, PyObject *args)
6638{
[391]6639 noborder( );
6640 Py_INCREF(Py_None);
6641 return Py_None;
[2]6642}
6643
6644/* void pntsmooth long s */
6645
6646static PyObject *
6647gl_pntsmooth(PyObject *self, PyObject *args)
6648{
[391]6649 long arg1 ;
6650 if (!getilongarg(args, 1, 0, &arg1))
6651 return NULL;
6652 pntsmooth( arg1 );
6653 Py_INCREF(Py_None);
6654 return Py_None;
[2]6655}
6656
6657/* void readsource long s */
6658
6659static PyObject *
6660gl_readsource(PyObject *self, PyObject *args)
6661{
[391]6662 long arg1 ;
6663 if (!getilongarg(args, 1, 0, &arg1))
6664 return NULL;
6665 readsource( arg1 );
6666 Py_INCREF(Py_None);
6667 return Py_None;
[2]6668}
6669
6670/* void rectzoom float s float s */
6671
6672static PyObject *
6673gl_rectzoom(PyObject *self, PyObject *args)
6674{
[391]6675 float arg1 ;
6676 float arg2 ;
6677 if (!getifloatarg(args, 2, 0, &arg1))
6678 return NULL;
6679 if (!getifloatarg(args, 2, 1, &arg2))
6680 return NULL;
6681 rectzoom( arg1 , arg2 );
6682 Py_INCREF(Py_None);
6683 return Py_None;
[2]6684}
6685
6686/* void sbox float s float s float s float s */
6687
6688static PyObject *
6689gl_sbox(PyObject *self, PyObject *args)
6690{
[391]6691 float arg1 ;
6692 float arg2 ;
6693 float arg3 ;
6694 float arg4 ;
6695 if (!getifloatarg(args, 4, 0, &arg1))
6696 return NULL;
6697 if (!getifloatarg(args, 4, 1, &arg2))
6698 return NULL;
6699 if (!getifloatarg(args, 4, 2, &arg3))
6700 return NULL;
6701 if (!getifloatarg(args, 4, 3, &arg4))
6702 return NULL;
6703 sbox( arg1 , arg2 , arg3 , arg4 );
6704 Py_INCREF(Py_None);
6705 return Py_None;
[2]6706}
6707
6708/* void sboxi long s long s long s long s */
6709
6710static PyObject *
6711gl_sboxi(PyObject *self, PyObject *args)
6712{
[391]6713 long arg1 ;
6714 long arg2 ;
6715 long arg3 ;
6716 long arg4 ;
6717 if (!getilongarg(args, 4, 0, &arg1))
6718 return NULL;
6719 if (!getilongarg(args, 4, 1, &arg2))
6720 return NULL;
6721 if (!getilongarg(args, 4, 2, &arg3))
6722 return NULL;
6723 if (!getilongarg(args, 4, 3, &arg4))
6724 return NULL;
6725 sboxi( arg1 , arg2 , arg3 , arg4 );
6726 Py_INCREF(Py_None);
6727 return Py_None;
[2]6728}
6729
6730/* void sboxs short s short s short s short s */
6731
6732static PyObject *
6733gl_sboxs(PyObject *self, PyObject *args)
6734{
[391]6735 short arg1 ;
6736 short arg2 ;
6737 short arg3 ;
6738 short arg4 ;
6739 if (!getishortarg(args, 4, 0, &arg1))
6740 return NULL;
6741 if (!getishortarg(args, 4, 1, &arg2))
6742 return NULL;
6743 if (!getishortarg(args, 4, 2, &arg3))
6744 return NULL;
6745 if (!getishortarg(args, 4, 3, &arg4))
6746 return NULL;
6747 sboxs( arg1 , arg2 , arg3 , arg4 );
6748 Py_INCREF(Py_None);
6749 return Py_None;
[2]6750}
6751
6752/* void sboxf float s float s float s float s */
6753
6754static PyObject *
6755gl_sboxf(PyObject *self, PyObject *args)
6756{
[391]6757 float arg1 ;
6758 float arg2 ;
6759 float arg3 ;
6760 float arg4 ;
6761 if (!getifloatarg(args, 4, 0, &arg1))
6762 return NULL;
6763 if (!getifloatarg(args, 4, 1, &arg2))
6764 return NULL;
6765 if (!getifloatarg(args, 4, 2, &arg3))
6766 return NULL;
6767 if (!getifloatarg(args, 4, 3, &arg4))
6768 return NULL;
6769 sboxf( arg1 , arg2 , arg3 , arg4 );
6770 Py_INCREF(Py_None);
6771 return Py_None;
[2]6772}
6773
6774/* void sboxfi long s long s long s long s */
6775
6776static PyObject *
6777gl_sboxfi(PyObject *self, PyObject *args)
6778{
[391]6779 long arg1 ;
6780 long arg2 ;
6781 long arg3 ;
6782 long arg4 ;
6783 if (!getilongarg(args, 4, 0, &arg1))
6784 return NULL;
6785 if (!getilongarg(args, 4, 1, &arg2))
6786 return NULL;
6787 if (!getilongarg(args, 4, 2, &arg3))
6788 return NULL;
6789 if (!getilongarg(args, 4, 3, &arg4))
6790 return NULL;
6791 sboxfi( arg1 , arg2 , arg3 , arg4 );
6792 Py_INCREF(Py_None);
6793 return Py_None;
[2]6794}
6795
6796/* void sboxfs short s short s short s short s */
6797
6798static PyObject *
6799gl_sboxfs(PyObject *self, PyObject *args)
6800{
[391]6801 short arg1 ;
6802 short arg2 ;
6803 short arg3 ;
6804 short arg4 ;
6805 if (!getishortarg(args, 4, 0, &arg1))
6806 return NULL;
6807 if (!getishortarg(args, 4, 1, &arg2))
6808 return NULL;
6809 if (!getishortarg(args, 4, 2, &arg3))
6810 return NULL;
6811 if (!getishortarg(args, 4, 3, &arg4))
6812 return NULL;
6813 sboxfs( arg1 , arg2 , arg3 , arg4 );
6814 Py_INCREF(Py_None);
6815 return Py_None;
[2]6816}
6817
6818/* void setnurbsproperty long s float s */
6819
6820static PyObject *
6821gl_setnurbsproperty(PyObject *self, PyObject *args)
6822{
[391]6823 long arg1 ;
6824 float arg2 ;
6825 if (!getilongarg(args, 2, 0, &arg1))
6826 return NULL;
6827 if (!getifloatarg(args, 2, 1, &arg2))
6828 return NULL;
6829 setnurbsproperty( arg1 , arg2 );
6830 Py_INCREF(Py_None);
6831 return Py_None;
[2]6832}
6833
6834/* void setpup long s long s long s */
6835
6836static PyObject *
6837gl_setpup(PyObject *self, PyObject *args)
6838{
[391]6839 long arg1 ;
6840 long arg2 ;
6841 long arg3 ;
6842 if (!getilongarg(args, 3, 0, &arg1))
6843 return NULL;
6844 if (!getilongarg(args, 3, 1, &arg2))
6845 return NULL;
6846 if (!getilongarg(args, 3, 2, &arg3))
6847 return NULL;
6848 setpup( arg1 , arg2 , arg3 );
6849 Py_INCREF(Py_None);
6850 return Py_None;
[2]6851}
6852
6853/* void smoothline long s */
6854
6855static PyObject *
6856gl_smoothline(PyObject *self, PyObject *args)
6857{
[391]6858 long arg1 ;
6859 if (!getilongarg(args, 1, 0, &arg1))
6860 return NULL;
6861 smoothline( arg1 );
6862 Py_INCREF(Py_None);
6863 return Py_None;
[2]6864}
6865
6866/* void subpixel long s */
6867
6868static PyObject *
6869gl_subpixel(PyObject *self, PyObject *args)
6870{
[391]6871 long arg1 ;
6872 if (!getilongarg(args, 1, 0, &arg1))
6873 return NULL;
6874 subpixel( arg1 );
6875 Py_INCREF(Py_None);
6876 return Py_None;
[2]6877}
6878
6879/* void swaptmesh */
6880
6881static PyObject *
6882gl_swaptmesh(PyObject *self, PyObject *args)
6883{
[391]6884 swaptmesh( );
6885 Py_INCREF(Py_None);
6886 return Py_None;
[2]6887}
6888
6889/* long swinopen long s */
6890
6891static PyObject *
6892gl_swinopen(PyObject *self, PyObject *args)
6893{
[391]6894 long retval;
6895 long arg1 ;
6896 if (!getilongarg(args, 1, 0, &arg1))
6897 return NULL;
6898 retval = swinopen( arg1 );
6899 return mknewlongobject(retval);
[2]6900}
6901
6902/* void v2f float s[2] */
6903
6904static PyObject *
6905gl_v2f(PyObject *self, PyObject *args)
6906{
[391]6907 float arg1 [ 2 ] ;
6908 if (!getifloatarray(args, 1, 0, 2 , arg1))
6909 return NULL;
6910 v2f( arg1 );
6911 Py_INCREF(Py_None);
6912 return Py_None;
[2]6913}
6914
6915/* void v2i long s[2] */
6916
6917static PyObject *
6918gl_v2i(PyObject *self, PyObject *args)
6919{
[391]6920 long arg1 [ 2 ] ;
6921 if (!getilongarray(args, 1, 0, 2 , arg1))
6922 return NULL;
6923 v2i( arg1 );
6924 Py_INCREF(Py_None);
6925 return Py_None;
[2]6926}
6927
6928/* void v2s short s[2] */
6929
6930static PyObject *
6931gl_v2s(PyObject *self, PyObject *args)
6932{
[391]6933 short arg1 [ 2 ] ;
6934 if (!getishortarray(args, 1, 0, 2 , arg1))
6935 return NULL;
6936 v2s( arg1 );
6937 Py_INCREF(Py_None);
6938 return Py_None;
[2]6939}
6940
6941/* void v3f float s[3] */
6942
6943static PyObject *
6944gl_v3f(PyObject *self, PyObject *args)
6945{
[391]6946 float arg1 [ 3 ] ;
6947 if (!getifloatarray(args, 1, 0, 3 , arg1))
6948 return NULL;
6949 v3f( arg1 );
6950 Py_INCREF(Py_None);
6951 return Py_None;
[2]6952}
6953
6954/* void v3i long s[3] */
6955
6956static PyObject *
6957gl_v3i(PyObject *self, PyObject *args)
6958{
[391]6959 long arg1 [ 3 ] ;
6960 if (!getilongarray(args, 1, 0, 3 , arg1))
6961 return NULL;
6962 v3i( arg1 );
6963 Py_INCREF(Py_None);
6964 return Py_None;
[2]6965}
6966
6967/* void v3s short s[3] */
6968
6969static PyObject *
6970gl_v3s(PyObject *self, PyObject *args)
6971{
[391]6972 short arg1 [ 3 ] ;
6973 if (!getishortarray(args, 1, 0, 3 , arg1))
6974 return NULL;
6975 v3s( arg1 );
6976 Py_INCREF(Py_None);
6977 return Py_None;
[2]6978}
6979
6980/* void v4f float s[4] */
6981
6982static PyObject *
6983gl_v4f(PyObject *self, PyObject *args)
6984{
[391]6985 float arg1 [ 4 ] ;
6986 if (!getifloatarray(args, 1, 0, 4 , arg1))
6987 return NULL;
6988 v4f( arg1 );
6989 Py_INCREF(Py_None);
6990 return Py_None;
[2]6991}
6992
6993/* void v4i long s[4] */
6994
6995static PyObject *
6996gl_v4i(PyObject *self, PyObject *args)
6997{
[391]6998 long arg1 [ 4 ] ;
6999 if (!getilongarray(args, 1, 0, 4 , arg1))
7000 return NULL;
7001 v4i( arg1 );
7002 Py_INCREF(Py_None);
7003 return Py_None;
[2]7004}
7005
7006/* void v4s short s[4] */
7007
7008static PyObject *
7009gl_v4s(PyObject *self, PyObject *args)
7010{
[391]7011 short arg1 [ 4 ] ;
7012 if (!getishortarray(args, 1, 0, 4 , arg1))
7013 return NULL;
7014 v4s( arg1 );
7015 Py_INCREF(Py_None);
7016 return Py_None;
[2]7017}
7018
7019/* void videocmd long s */
7020
7021static PyObject *
7022gl_videocmd(PyObject *self, PyObject *args)
7023{
[391]7024 long arg1 ;
7025 if (!getilongarg(args, 1, 0, &arg1))
7026 return NULL;
7027 videocmd( arg1 );
7028 Py_INCREF(Py_None);
7029 return Py_None;
[2]7030}
7031
7032/* long windepth long s */
7033
7034static PyObject *
7035gl_windepth(PyObject *self, PyObject *args)
7036{
[391]7037 long retval;
7038 long arg1 ;
7039 if (!getilongarg(args, 1, 0, &arg1))
7040 return NULL;
7041 retval = windepth( arg1 );
7042 return mknewlongobject(retval);
[2]7043}
7044
7045/* void wmpack long s */
7046
7047static PyObject *
7048gl_wmpack(PyObject *self, PyObject *args)
7049{
[391]7050 long arg1 ;
7051 if (!getilongarg(args, 1, 0, &arg1))
7052 return NULL;
7053 wmpack( arg1 );
7054 Py_INCREF(Py_None);
7055 return Py_None;
[2]7056}
7057
7058/* void zdraw long s */
7059
7060static PyObject *
7061gl_zdraw(PyObject *self, PyObject *args)
7062{
[391]7063 long arg1 ;
7064 if (!getilongarg(args, 1, 0, &arg1))
7065 return NULL;
7066 zdraw( arg1 );
7067 Py_INCREF(Py_None);
7068 return Py_None;
[2]7069}
7070
7071/* void zfunction long s */
7072
7073static PyObject *
7074gl_zfunction(PyObject *self, PyObject *args)
7075{
[391]7076 long arg1 ;
7077 if (!getilongarg(args, 1, 0, &arg1))
7078 return NULL;
7079 zfunction( arg1 );
7080 Py_INCREF(Py_None);
7081 return Py_None;
[2]7082}
7083
7084/* void zsource long s */
7085
7086static PyObject *
7087gl_zsource(PyObject *self, PyObject *args)
7088{
[391]7089 long arg1 ;
7090 if (!getilongarg(args, 1, 0, &arg1))
7091 return NULL;
7092 zsource( arg1 );
7093 Py_INCREF(Py_None);
7094 return Py_None;
[2]7095}
7096
7097/* void zwritemask long s */
7098
7099static PyObject *
7100gl_zwritemask(PyObject *self, PyObject *args)
7101{
[391]7102 long arg1 ;
7103 if (!getilongarg(args, 1, 0, &arg1))
7104 return NULL;
7105 zwritemask( arg1 );
7106 Py_INCREF(Py_None);
7107 return Py_None;
[2]7108}
7109
7110/* void v2d double s[2] */
7111
7112static PyObject *
7113gl_v2d(PyObject *self, PyObject *args)
7114{
[391]7115 double arg1 [ 2 ] ;
7116 if (!getidoublearray(args, 1, 0, 2 , arg1))
7117 return NULL;
7118 v2d( arg1 );
7119 Py_INCREF(Py_None);
7120 return Py_None;
[2]7121}
7122
7123/* void v3d double s[3] */
7124
7125static PyObject *
7126gl_v3d(PyObject *self, PyObject *args)
7127{
[391]7128 double arg1 [ 3 ] ;
7129 if (!getidoublearray(args, 1, 0, 3 , arg1))
7130 return NULL;
7131 v3d( arg1 );
7132 Py_INCREF(Py_None);
7133 return Py_None;
[2]7134}
7135
7136/* void v4d double s[4] */
7137
7138static PyObject *
7139gl_v4d(PyObject *self, PyObject *args)
7140{
[391]7141 double arg1 [ 4 ] ;
7142 if (!getidoublearray(args, 1, 0, 4 , arg1))
7143 return NULL;
7144 v4d( arg1 );
7145 Py_INCREF(Py_None);
7146 return Py_None;
[2]7147}
7148
7149/* void pixmode long s long s */
7150
7151static PyObject *
7152gl_pixmode(PyObject *self, PyObject *args)
7153{
[391]7154 long arg1 ;
7155 long arg2 ;
7156 if (!getilongarg(args, 2, 0, &arg1))
7157 return NULL;
7158 if (!getilongarg(args, 2, 1, &arg2))
7159 return NULL;
7160 pixmode( arg1 , arg2 );
7161 Py_INCREF(Py_None);
7162 return Py_None;
[2]7163}
7164
7165/* long qgetfd */
7166
7167static PyObject *
7168gl_qgetfd(PyObject *self, PyObject *args)
7169{
[391]7170 long retval;
7171 retval = qgetfd( );
7172 return mknewlongobject(retval);
[2]7173}
7174
7175/* void dither long s */
7176
7177static PyObject *
7178gl_dither(PyObject *self, PyObject *args)
7179{
[391]7180 long arg1 ;
7181 if (!getilongarg(args, 1, 0, &arg1))
7182 return NULL;
7183 dither( arg1 );
7184 Py_INCREF(Py_None);
7185 return Py_None;
[2]7186}
7187
7188static struct PyMethodDef gl_methods[] = {
[391]7189 {"qread", gl_qread, METH_OLDARGS},
7190 {"varray", gl_varray, METH_OLDARGS},
7191 {"nvarray", gl_nvarray, METH_OLDARGS},
7192 {"vnarray", gl_vnarray, METH_OLDARGS},
7193 {"nurbssurface", gl_nurbssurface, METH_OLDARGS},
7194 {"nurbscurve", gl_nurbscurve, METH_OLDARGS},
7195 {"pwlcurve", gl_pwlcurve, METH_OLDARGS},
7196 {"pick", gl_pick, METH_OLDARGS},
7197 {"endpick", gl_endpick, METH_NOARGS},
7198 {"gselect", gl_gselect, METH_OLDARGS},
7199 {"endselect", gl_endselect, METH_NOARGS},
7200 {"getmatrix", gl_getmatrix, METH_OLDARGS},
7201 {"altgetmatrix", gl_altgetmatrix, METH_OLDARGS},
7202 {"lrectwrite", gl_lrectwrite, METH_OLDARGS},
7203 {"lrectread", gl_lrectread, METH_OLDARGS},
7204 {"readdisplay", gl_readdisplay, METH_OLDARGS},
7205 {"packrect", gl_packrect, METH_OLDARGS},
7206 {"unpackrect", gl_unpackrect, METH_OLDARGS},
7207 {"gversion", gl_gversion, METH_OLDARGS},
7208 {"clear", gl_clear, METH_OLDARGS},
7209 {"getshade", gl_getshade, METH_OLDARGS},
7210 {"devport", gl_devport, METH_OLDARGS},
7211 {"rdr2i", gl_rdr2i, METH_OLDARGS},
7212 {"rectfs", gl_rectfs, METH_OLDARGS},
7213 {"rects", gl_rects, METH_OLDARGS},
7214 {"rmv2i", gl_rmv2i, METH_OLDARGS},
7215 {"noport", gl_noport, METH_OLDARGS},
7216 {"popviewport", gl_popviewport, METH_OLDARGS},
7217 {"clearhitcode", gl_clearhitcode, METH_OLDARGS},
7218 {"closeobj", gl_closeobj, METH_OLDARGS},
7219 {"cursoff", gl_cursoff, METH_OLDARGS},
7220 {"curson", gl_curson, METH_OLDARGS},
7221 {"doublebuffer", gl_doublebuffer, METH_OLDARGS},
7222 {"finish", gl_finish, METH_OLDARGS},
7223 {"gconfig", gl_gconfig, METH_OLDARGS},
7224 {"ginit", gl_ginit, METH_OLDARGS},
7225 {"greset", gl_greset, METH_OLDARGS},
7226 {"multimap", gl_multimap, METH_OLDARGS},
7227 {"onemap", gl_onemap, METH_OLDARGS},
7228 {"popattributes", gl_popattributes, METH_OLDARGS},
7229 {"popmatrix", gl_popmatrix, METH_OLDARGS},
7230 {"pushattributes", gl_pushattributes,METH_OLDARGS},
7231 {"pushmatrix", gl_pushmatrix, METH_OLDARGS},
7232 {"pushviewport", gl_pushviewport, METH_OLDARGS},
7233 {"qreset", gl_qreset, METH_OLDARGS},
7234 {"RGBmode", gl_RGBmode, METH_OLDARGS},
7235 {"singlebuffer", gl_singlebuffer, METH_OLDARGS},
7236 {"swapbuffers", gl_swapbuffers, METH_OLDARGS},
7237 {"gsync", gl_gsync, METH_OLDARGS},
7238 {"gflush", gl_gflush, METH_OLDARGS},
7239 {"tpon", gl_tpon, METH_OLDARGS},
7240 {"tpoff", gl_tpoff, METH_OLDARGS},
7241 {"clkon", gl_clkon, METH_OLDARGS},
7242 {"clkoff", gl_clkoff, METH_OLDARGS},
7243 {"ringbell", gl_ringbell, METH_OLDARGS},
7244 {"gbegin", gl_gbegin, METH_OLDARGS},
7245 {"textinit", gl_textinit, METH_OLDARGS},
7246 {"initnames", gl_initnames, METH_OLDARGS},
7247 {"pclos", gl_pclos, METH_OLDARGS},
7248 {"popname", gl_popname, METH_OLDARGS},
7249 {"spclos", gl_spclos, METH_OLDARGS},
7250 {"zclear", gl_zclear, METH_OLDARGS},
7251 {"screenspace", gl_screenspace, METH_OLDARGS},
7252 {"reshapeviewport", gl_reshapeviewport, METH_OLDARGS},
7253 {"winpush", gl_winpush, METH_OLDARGS},
7254 {"winpop", gl_winpop, METH_OLDARGS},
7255 {"foreground", gl_foreground, METH_OLDARGS},
7256 {"endfullscrn", gl_endfullscrn, METH_OLDARGS},
7257 {"endpupmode", gl_endpupmode, METH_OLDARGS},
7258 {"fullscrn", gl_fullscrn, METH_OLDARGS},
7259 {"pupmode", gl_pupmode, METH_OLDARGS},
7260 {"winconstraints", gl_winconstraints, METH_OLDARGS},
7261 {"pagecolor", gl_pagecolor, METH_OLDARGS},
7262 {"textcolor", gl_textcolor, METH_OLDARGS},
7263 {"color", gl_color, METH_OLDARGS},
7264 {"curveit", gl_curveit, METH_OLDARGS},
7265 {"font", gl_font, METH_OLDARGS},
7266 {"linewidth", gl_linewidth, METH_OLDARGS},
7267 {"setlinestyle", gl_setlinestyle, METH_OLDARGS},
7268 {"setmap", gl_setmap, METH_OLDARGS},
7269 {"swapinterval", gl_swapinterval, METH_OLDARGS},
7270 {"writemask", gl_writemask, METH_OLDARGS},
7271 {"textwritemask", gl_textwritemask, METH_OLDARGS},
7272 {"qdevice", gl_qdevice, METH_OLDARGS},
7273 {"unqdevice", gl_unqdevice, METH_OLDARGS},
7274 {"curvebasis", gl_curvebasis, METH_OLDARGS},
7275 {"curveprecision", gl_curveprecision,METH_OLDARGS},
7276 {"loadname", gl_loadname, METH_OLDARGS},
7277 {"passthrough", gl_passthrough, METH_OLDARGS},
7278 {"pushname", gl_pushname, METH_OLDARGS},
7279 {"setmonitor", gl_setmonitor, METH_OLDARGS},
7280 {"setshade", gl_setshade, METH_OLDARGS},
7281 {"setpattern", gl_setpattern, METH_OLDARGS},
7282 {"pagewritemask", gl_pagewritemask, METH_OLDARGS},
7283 {"callobj", gl_callobj, METH_OLDARGS},
7284 {"delobj", gl_delobj, METH_OLDARGS},
7285 {"editobj", gl_editobj, METH_OLDARGS},
7286 {"makeobj", gl_makeobj, METH_OLDARGS},
7287 {"maketag", gl_maketag, METH_OLDARGS},
7288 {"chunksize", gl_chunksize, METH_OLDARGS},
7289 {"compactify", gl_compactify, METH_OLDARGS},
7290 {"deltag", gl_deltag, METH_OLDARGS},
7291 {"lsrepeat", gl_lsrepeat, METH_OLDARGS},
7292 {"objinsert", gl_objinsert, METH_OLDARGS},
7293 {"objreplace", gl_objreplace, METH_OLDARGS},
7294 {"winclose", gl_winclose, METH_OLDARGS},
7295 {"blanktime", gl_blanktime, METH_OLDARGS},
7296 {"freepup", gl_freepup, METH_OLDARGS},
7297 {"backbuffer", gl_backbuffer, METH_OLDARGS},
7298 {"frontbuffer", gl_frontbuffer, METH_OLDARGS},
7299 {"lsbackup", gl_lsbackup, METH_OLDARGS},
7300 {"resetls", gl_resetls, METH_OLDARGS},
7301 {"lampon", gl_lampon, METH_OLDARGS},
7302 {"lampoff", gl_lampoff, METH_OLDARGS},
7303 {"setbell", gl_setbell, METH_OLDARGS},
7304 {"blankscreen", gl_blankscreen, METH_OLDARGS},
7305 {"depthcue", gl_depthcue, METH_OLDARGS},
7306 {"zbuffer", gl_zbuffer, METH_OLDARGS},
7307 {"backface", gl_backface, METH_OLDARGS},
7308 {"cmov2i", gl_cmov2i, METH_OLDARGS},
7309 {"draw2i", gl_draw2i, METH_OLDARGS},
7310 {"move2i", gl_move2i, METH_OLDARGS},
7311 {"pnt2i", gl_pnt2i, METH_OLDARGS},
7312 {"patchbasis", gl_patchbasis, METH_OLDARGS},
7313 {"patchprecision", gl_patchprecision, METH_OLDARGS},
7314 {"pdr2i", gl_pdr2i, METH_OLDARGS},
7315 {"pmv2i", gl_pmv2i, METH_OLDARGS},
7316 {"rpdr2i", gl_rpdr2i, METH_OLDARGS},
7317 {"rpmv2i", gl_rpmv2i, METH_OLDARGS},
7318 {"xfpt2i", gl_xfpt2i, METH_OLDARGS},
7319 {"objdelete", gl_objdelete, METH_OLDARGS},
7320 {"patchcurves", gl_patchcurves, METH_OLDARGS},
7321 {"minsize", gl_minsize, METH_OLDARGS},
7322 {"maxsize", gl_maxsize, METH_OLDARGS},
7323 {"keepaspect", gl_keepaspect, METH_OLDARGS},
7324 {"prefsize", gl_prefsize, METH_OLDARGS},
7325 {"stepunit", gl_stepunit, METH_OLDARGS},
7326 {"fudge", gl_fudge, METH_OLDARGS},
7327 {"winmove", gl_winmove, METH_OLDARGS},
7328 {"attachcursor", gl_attachcursor, METH_OLDARGS},
7329 {"deflinestyle", gl_deflinestyle, METH_OLDARGS},
7330 {"noise", gl_noise, METH_OLDARGS},
7331 {"picksize", gl_picksize, METH_OLDARGS},
7332 {"qenter", gl_qenter, METH_OLDARGS},
7333 {"setdepth", gl_setdepth, METH_OLDARGS},
7334 {"cmov2s", gl_cmov2s, METH_OLDARGS},
7335 {"draw2s", gl_draw2s, METH_OLDARGS},
7336 {"move2s", gl_move2s, METH_OLDARGS},
7337 {"pdr2s", gl_pdr2s, METH_OLDARGS},
7338 {"pmv2s", gl_pmv2s, METH_OLDARGS},
7339 {"pnt2s", gl_pnt2s, METH_OLDARGS},
7340 {"rdr2s", gl_rdr2s, METH_OLDARGS},
7341 {"rmv2s", gl_rmv2s, METH_OLDARGS},
7342 {"rpdr2s", gl_rpdr2s, METH_OLDARGS},
7343 {"rpmv2s", gl_rpmv2s, METH_OLDARGS},
7344 {"xfpt2s", gl_xfpt2s, METH_OLDARGS},
7345 {"cmov2", gl_cmov2, METH_OLDARGS},
7346 {"draw2", gl_draw2, METH_OLDARGS},
7347 {"move2", gl_move2, METH_OLDARGS},
7348 {"pnt2", gl_pnt2, METH_OLDARGS},
7349 {"pdr2", gl_pdr2, METH_OLDARGS},
7350 {"pmv2", gl_pmv2, METH_OLDARGS},
7351 {"rdr2", gl_rdr2, METH_OLDARGS},
7352 {"rmv2", gl_rmv2, METH_OLDARGS},
7353 {"rpdr2", gl_rpdr2, METH_OLDARGS},
7354 {"rpmv2", gl_rpmv2, METH_OLDARGS},
7355 {"xfpt2", gl_xfpt2, METH_OLDARGS},
7356 {"loadmatrix", gl_loadmatrix, METH_OLDARGS},
7357 {"multmatrix", gl_multmatrix, METH_OLDARGS},
7358 {"crv", gl_crv, METH_OLDARGS},
7359 {"rcrv", gl_rcrv, METH_OLDARGS},
7360 {"addtopup", gl_addtopup, METH_OLDARGS},
7361 {"charstr", gl_charstr, METH_OLDARGS},
7362 {"getport", gl_getport, METH_OLDARGS},
7363 {"strwidth", gl_strwidth, METH_OLDARGS},
7364 {"winopen", gl_winopen, METH_OLDARGS},
7365 {"wintitle", gl_wintitle, METH_OLDARGS},
7366 {"polf", gl_polf, METH_OLDARGS},
7367 {"polf2", gl_polf2, METH_OLDARGS},
7368 {"poly", gl_poly, METH_OLDARGS},
7369 {"poly2", gl_poly2, METH_OLDARGS},
7370 {"crvn", gl_crvn, METH_OLDARGS},
7371 {"rcrvn", gl_rcrvn, METH_OLDARGS},
7372 {"polf2i", gl_polf2i, METH_OLDARGS},
7373 {"polfi", gl_polfi, METH_OLDARGS},
7374 {"poly2i", gl_poly2i, METH_OLDARGS},
7375 {"polyi", gl_polyi, METH_OLDARGS},
7376 {"polf2s", gl_polf2s, METH_OLDARGS},
7377 {"polfs", gl_polfs, METH_OLDARGS},
7378 {"polys", gl_polys, METH_OLDARGS},
7379 {"poly2s", gl_poly2s, METH_OLDARGS},
7380 {"defcursor", gl_defcursor, METH_OLDARGS},
7381 {"writepixels", gl_writepixels, METH_OLDARGS},
7382 {"defbasis", gl_defbasis, METH_OLDARGS},
7383 {"gewrite", gl_gewrite, METH_OLDARGS},
7384 {"rotate", gl_rotate, METH_OLDARGS},
7385 {"rot", gl_rot, METH_OLDARGS},
7386 {"circfi", gl_circfi, METH_OLDARGS},
7387 {"circi", gl_circi, METH_OLDARGS},
7388 {"cmovi", gl_cmovi, METH_OLDARGS},
7389 {"drawi", gl_drawi, METH_OLDARGS},
7390 {"movei", gl_movei, METH_OLDARGS},
7391 {"pnti", gl_pnti, METH_OLDARGS},
7392 {"newtag", gl_newtag, METH_OLDARGS},
7393 {"pdri", gl_pdri, METH_OLDARGS},
7394 {"pmvi", gl_pmvi, METH_OLDARGS},
7395 {"rdri", gl_rdri, METH_OLDARGS},
7396 {"rmvi", gl_rmvi, METH_OLDARGS},
7397 {"rpdri", gl_rpdri, METH_OLDARGS},
7398 {"rpmvi", gl_rpmvi, METH_OLDARGS},
7399 {"xfpti", gl_xfpti, METH_OLDARGS},
7400 {"circ", gl_circ, METH_OLDARGS},
7401 {"circf", gl_circf, METH_OLDARGS},
7402 {"cmov", gl_cmov, METH_OLDARGS},
7403 {"draw", gl_draw, METH_OLDARGS},
7404 {"move", gl_move, METH_OLDARGS},
7405 {"pnt", gl_pnt, METH_OLDARGS},
7406 {"scale", gl_scale, METH_OLDARGS},
7407 {"translate", gl_translate, METH_OLDARGS},
7408 {"pdr", gl_pdr, METH_OLDARGS},
7409 {"pmv", gl_pmv, METH_OLDARGS},
7410 {"rdr", gl_rdr, METH_OLDARGS},
7411 {"rmv", gl_rmv, METH_OLDARGS},
7412 {"rpdr", gl_rpdr, METH_OLDARGS},
7413 {"rpmv", gl_rpmv, METH_OLDARGS},
7414 {"xfpt", gl_xfpt, METH_OLDARGS},
7415 {"RGBcolor", gl_RGBcolor, METH_OLDARGS},
7416 {"RGBwritemask", gl_RGBwritemask, METH_OLDARGS},
7417 {"setcursor", gl_setcursor, METH_OLDARGS},
7418 {"tie", gl_tie, METH_OLDARGS},
7419 {"circfs", gl_circfs, METH_OLDARGS},
7420 {"circs", gl_circs, METH_OLDARGS},
7421 {"cmovs", gl_cmovs, METH_OLDARGS},
7422 {"draws", gl_draws, METH_OLDARGS},
7423 {"moves", gl_moves, METH_OLDARGS},
7424 {"pdrs", gl_pdrs, METH_OLDARGS},
7425 {"pmvs", gl_pmvs, METH_OLDARGS},
7426 {"pnts", gl_pnts, METH_OLDARGS},
7427 {"rdrs", gl_rdrs, METH_OLDARGS},
7428 {"rmvs", gl_rmvs, METH_OLDARGS},
7429 {"rpdrs", gl_rpdrs, METH_OLDARGS},
7430 {"rpmvs", gl_rpmvs, METH_OLDARGS},
7431 {"xfpts", gl_xfpts, METH_OLDARGS},
7432 {"curorigin", gl_curorigin, METH_OLDARGS},
7433 {"cyclemap", gl_cyclemap, METH_OLDARGS},
7434 {"patch", gl_patch, METH_OLDARGS},
7435 {"splf", gl_splf, METH_OLDARGS},
7436 {"splf2", gl_splf2, METH_OLDARGS},
7437 {"splfi", gl_splfi, METH_OLDARGS},
7438 {"splf2i", gl_splf2i, METH_OLDARGS},
7439 {"splfs", gl_splfs, METH_OLDARGS},
7440 {"splf2s", gl_splf2s, METH_OLDARGS},
7441 {"rpatch", gl_rpatch, METH_OLDARGS},
7442 {"ortho2", gl_ortho2, METH_OLDARGS},
7443 {"rect", gl_rect, METH_OLDARGS},
7444 {"rectf", gl_rectf, METH_OLDARGS},
7445 {"xfpt4", gl_xfpt4, METH_OLDARGS},
7446 {"textport", gl_textport, METH_OLDARGS},
7447 {"mapcolor", gl_mapcolor, METH_OLDARGS},
7448 {"scrmask", gl_scrmask, METH_OLDARGS},
7449 {"setvaluator", gl_setvaluator, METH_OLDARGS},
7450 {"viewport", gl_viewport, METH_OLDARGS},
7451 {"shaderange", gl_shaderange, METH_OLDARGS},
7452 {"xfpt4s", gl_xfpt4s, METH_OLDARGS},
7453 {"rectfi", gl_rectfi, METH_OLDARGS},
7454 {"recti", gl_recti, METH_OLDARGS},
7455 {"xfpt4i", gl_xfpt4i, METH_OLDARGS},
7456 {"prefposition", gl_prefposition, METH_OLDARGS},
7457 {"arc", gl_arc, METH_OLDARGS},
7458 {"arcf", gl_arcf, METH_OLDARGS},
7459 {"arcfi", gl_arcfi, METH_OLDARGS},
7460 {"arci", gl_arci, METH_OLDARGS},
7461 {"bbox2", gl_bbox2, METH_OLDARGS},
7462 {"bbox2i", gl_bbox2i, METH_OLDARGS},
7463 {"bbox2s", gl_bbox2s, METH_OLDARGS},
7464 {"blink", gl_blink, METH_OLDARGS},
7465 {"ortho", gl_ortho, METH_OLDARGS},
7466 {"window", gl_window, METH_OLDARGS},
7467 {"lookat", gl_lookat, METH_OLDARGS},
7468 {"perspective", gl_perspective, METH_OLDARGS},
7469 {"polarview", gl_polarview, METH_OLDARGS},
7470 {"arcfs", gl_arcfs, METH_OLDARGS},
7471 {"arcs", gl_arcs, METH_OLDARGS},
7472 {"rectcopy", gl_rectcopy, METH_OLDARGS},
7473 {"RGBcursor", gl_RGBcursor, METH_OLDARGS},
7474 {"getbutton", gl_getbutton, METH_OLDARGS},
7475 {"getcmmode", gl_getcmmode, METH_OLDARGS},
7476 {"getlsbackup", gl_getlsbackup, METH_OLDARGS},
7477 {"getresetls", gl_getresetls, METH_OLDARGS},
7478 {"getdcm", gl_getdcm, METH_OLDARGS},
7479 {"getzbuffer", gl_getzbuffer, METH_OLDARGS},
7480 {"ismex", gl_ismex, METH_OLDARGS},
7481 {"isobj", gl_isobj, METH_OLDARGS},
7482 {"isqueued", gl_isqueued, METH_OLDARGS},
7483 {"istag", gl_istag, METH_OLDARGS},
7484 {"genobj", gl_genobj, METH_OLDARGS},
7485 {"gentag", gl_gentag, METH_OLDARGS},
7486 {"getbuffer", gl_getbuffer, METH_OLDARGS},
7487 {"getcolor", gl_getcolor, METH_OLDARGS},
7488 {"getdisplaymode", gl_getdisplaymode, METH_OLDARGS},
7489 {"getfont", gl_getfont, METH_OLDARGS},
7490 {"getheight", gl_getheight, METH_OLDARGS},
7491 {"gethitcode", gl_gethitcode, METH_OLDARGS},
7492 {"getlstyle", gl_getlstyle, METH_OLDARGS},
7493 {"getlwidth", gl_getlwidth, METH_OLDARGS},
7494 {"getmap", gl_getmap, METH_OLDARGS},
7495 {"getplanes", gl_getplanes, METH_OLDARGS},
7496 {"getwritemask", gl_getwritemask, METH_OLDARGS},
7497 {"qtest", gl_qtest, METH_OLDARGS},
7498 {"getlsrepeat", gl_getlsrepeat, METH_OLDARGS},
7499 {"getmonitor", gl_getmonitor, METH_OLDARGS},
7500 {"getopenobj", gl_getopenobj, METH_OLDARGS},
7501 {"getpattern", gl_getpattern, METH_OLDARGS},
7502 {"winget", gl_winget, METH_OLDARGS},
7503 {"winattach", gl_winattach, METH_OLDARGS},
7504 {"getothermonitor", gl_getothermonitor, METH_OLDARGS},
7505 {"newpup", gl_newpup, METH_OLDARGS},
7506 {"getvaluator", gl_getvaluator, METH_OLDARGS},
7507 {"winset", gl_winset, METH_OLDARGS},
7508 {"dopup", gl_dopup, METH_OLDARGS},
7509 {"getdepth", gl_getdepth, METH_OLDARGS},
7510 {"getcpos", gl_getcpos, METH_OLDARGS},
7511 {"getsize", gl_getsize, METH_OLDARGS},
7512 {"getorigin", gl_getorigin, METH_OLDARGS},
7513 {"getviewport", gl_getviewport, METH_OLDARGS},
7514 {"gettp", gl_gettp, METH_OLDARGS},
7515 {"getgpos", gl_getgpos, METH_OLDARGS},
7516 {"winposition", gl_winposition, METH_OLDARGS},
7517 {"gRGBcolor", gl_gRGBcolor, METH_OLDARGS},
7518 {"gRGBmask", gl_gRGBmask, METH_OLDARGS},
7519 {"getscrmask", gl_getscrmask, METH_OLDARGS},
7520 {"getmcolor", gl_getmcolor, METH_OLDARGS},
7521 {"mapw", gl_mapw, METH_OLDARGS},
7522 {"mapw2", gl_mapw2, METH_OLDARGS},
7523 {"getcursor", gl_getcursor, METH_OLDARGS},
7524 {"cmode", gl_cmode, METH_OLDARGS},
7525 {"concave", gl_concave, METH_OLDARGS},
7526 {"curstype", gl_curstype, METH_OLDARGS},
7527 {"drawmode", gl_drawmode, METH_OLDARGS},
7528 {"gammaramp", gl_gammaramp, METH_OLDARGS},
7529 {"getbackface", gl_getbackface, METH_OLDARGS},
7530 {"getdescender", gl_getdescender, METH_OLDARGS},
7531 {"getdrawmode", gl_getdrawmode, METH_OLDARGS},
7532 {"getmmode", gl_getmmode, METH_OLDARGS},
7533 {"getsm", gl_getsm, METH_OLDARGS},
7534 {"getvideo", gl_getvideo, METH_OLDARGS},
7535 {"imakebackground", gl_imakebackground, METH_OLDARGS},
7536 {"lmbind", gl_lmbind, METH_OLDARGS},
7537 {"lmdef", gl_lmdef, METH_OLDARGS},
7538 {"mmode", gl_mmode, METH_OLDARGS},
7539 {"normal", gl_normal, METH_OLDARGS},
7540 {"overlay", gl_overlay, METH_OLDARGS},
7541 {"RGBrange", gl_RGBrange, METH_OLDARGS},
7542 {"setvideo", gl_setvideo, METH_OLDARGS},
7543 {"shademodel", gl_shademodel, METH_OLDARGS},
7544 {"underlay", gl_underlay, METH_OLDARGS},
7545 {"bgnclosedline", gl_bgnclosedline, METH_OLDARGS},
7546 {"bgnline", gl_bgnline, METH_OLDARGS},
7547 {"bgnpoint", gl_bgnpoint, METH_OLDARGS},
7548 {"bgnpolygon", gl_bgnpolygon, METH_OLDARGS},
7549 {"bgnsurface", gl_bgnsurface, METH_OLDARGS},
7550 {"bgntmesh", gl_bgntmesh, METH_OLDARGS},
7551 {"bgntrim", gl_bgntrim, METH_OLDARGS},
7552 {"endclosedline", gl_endclosedline, METH_OLDARGS},
7553 {"endline", gl_endline, METH_OLDARGS},
7554 {"endpoint", gl_endpoint, METH_OLDARGS},
7555 {"endpolygon", gl_endpolygon, METH_OLDARGS},
7556 {"endsurface", gl_endsurface, METH_OLDARGS},
7557 {"endtmesh", gl_endtmesh, METH_OLDARGS},
7558 {"endtrim", gl_endtrim, METH_OLDARGS},
7559 {"blendfunction", gl_blendfunction, METH_OLDARGS},
7560 {"c3f", gl_c3f, METH_OLDARGS},
7561 {"c3i", gl_c3i, METH_OLDARGS},
7562 {"c3s", gl_c3s, METH_OLDARGS},
7563 {"c4f", gl_c4f, METH_OLDARGS},
7564 {"c4i", gl_c4i, METH_OLDARGS},
7565 {"c4s", gl_c4s, METH_OLDARGS},
7566 {"colorf", gl_colorf, METH_OLDARGS},
7567 {"cpack", gl_cpack, METH_OLDARGS},
7568 {"czclear", gl_czclear, METH_OLDARGS},
7569 {"dglclose", gl_dglclose, METH_OLDARGS},
7570 {"dglopen", gl_dglopen, METH_OLDARGS},
7571 {"getgdesc", gl_getgdesc, METH_OLDARGS},
7572 {"getnurbsproperty", gl_getnurbsproperty, METH_OLDARGS},
7573 {"glcompat", gl_glcompat, METH_OLDARGS},
7574 {"iconsize", gl_iconsize, METH_OLDARGS},
7575 {"icontitle", gl_icontitle, METH_OLDARGS},
7576 {"lRGBrange", gl_lRGBrange, METH_OLDARGS},
7577 {"linesmooth", gl_linesmooth, METH_OLDARGS},
7578 {"lmcolor", gl_lmcolor, METH_OLDARGS},
7579 {"logicop", gl_logicop, METH_OLDARGS},
7580 {"lsetdepth", gl_lsetdepth, METH_OLDARGS},
7581 {"lshaderange", gl_lshaderange, METH_OLDARGS},
7582 {"n3f", gl_n3f, METH_OLDARGS},
7583 {"noborder", gl_noborder, METH_OLDARGS},
7584 {"pntsmooth", gl_pntsmooth, METH_OLDARGS},
7585 {"readsource", gl_readsource, METH_OLDARGS},
7586 {"rectzoom", gl_rectzoom, METH_OLDARGS},
7587 {"sbox", gl_sbox, METH_OLDARGS},
7588 {"sboxi", gl_sboxi, METH_OLDARGS},
7589 {"sboxs", gl_sboxs, METH_OLDARGS},
7590 {"sboxf", gl_sboxf, METH_OLDARGS},
7591 {"sboxfi", gl_sboxfi, METH_OLDARGS},
7592 {"sboxfs", gl_sboxfs, METH_OLDARGS},
7593 {"setnurbsproperty", gl_setnurbsproperty, METH_OLDARGS},
7594 {"setpup", gl_setpup, METH_OLDARGS},
7595 {"smoothline", gl_smoothline, METH_OLDARGS},
7596 {"subpixel", gl_subpixel, METH_OLDARGS},
7597 {"swaptmesh", gl_swaptmesh, METH_OLDARGS},
7598 {"swinopen", gl_swinopen, METH_OLDARGS},
7599 {"v2f", gl_v2f, METH_OLDARGS},
7600 {"v2i", gl_v2i, METH_OLDARGS},
7601 {"v2s", gl_v2s, METH_OLDARGS},
7602 {"v3f", gl_v3f, METH_OLDARGS},
7603 {"v3i", gl_v3i, METH_OLDARGS},
7604 {"v3s", gl_v3s, METH_OLDARGS},
7605 {"v4f", gl_v4f, METH_OLDARGS},
7606 {"v4i", gl_v4i, METH_OLDARGS},
7607 {"v4s", gl_v4s, METH_OLDARGS},
7608 {"videocmd", gl_videocmd, METH_OLDARGS},
7609 {"windepth", gl_windepth, METH_OLDARGS},
7610 {"wmpack", gl_wmpack, METH_OLDARGS},
7611 {"zdraw", gl_zdraw, METH_OLDARGS},
7612 {"zfunction", gl_zfunction, METH_OLDARGS},
7613 {"zsource", gl_zsource, METH_OLDARGS},
7614 {"zwritemask", gl_zwritemask, METH_OLDARGS},
7615 {"v2d", gl_v2d, METH_OLDARGS},
7616 {"v3d", gl_v3d, METH_OLDARGS},
7617 {"v4d", gl_v4d, METH_OLDARGS},
7618 {"pixmode", gl_pixmode, METH_OLDARGS},
7619 {"qgetfd", gl_qgetfd, METH_OLDARGS},
7620 {"dither", gl_dither, METH_OLDARGS},
7621 {NULL, NULL} /* Sentinel */
[2]7622};
7623
7624void
7625initgl(void)
7626{
[391]7627
[2]7628 if (PyErr_WarnPy3k("the gl module has been removed in "
7629 "Python 3.0", 2) < 0)
[391]7630 return;
7631
7632 (void) Py_InitModule("gl", gl_methods);
[2]7633}
Note: See TracBrowser for help on using the repository browser.