← Back to branch summary

~malept/ubuntu/lucid/python2.6/dev-dependency-fix

« back to all changes in this revision

Viewing changes to Modules/glmodule.c

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2009-02-13 12:51:00 UTC
  • Revision ID: james.westby@ubuntu.com-20090213125100-uufgcb9yeqzujpqw
Tags: upstream-2.6.1
Import upstream version 2.6.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
Modules/glmodule.c
 
1
 
 
2
/*
 
3
Input used to generate the Python module "glmodule.c".
 
4
The stub generator is a Python script called "cgen.py".
 
5
 
 
6
Each 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
 
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
 
16
 
 
17
<arg> has the form <mode> or <mode>[<subscript>]
 
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.
 
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
 
44
extern int devport();
 
45
extern int textwritemask();
 
46
extern int pagewritemask();
 
47
extern int gewrite();
 
48
extern int gettp();
 
49
#endif
 
50
 
 
51
#include "Python.h"
 
52
#include "cgensupport.h"
 
53
 
 
54
/*
 
55
Some stubs are too complicated for the stub generator.
 
56
We can include manually written versions of them here.
 
57
A line starting with '%' gives the name of the function so the stub
 
58
generator can include it in the table of functions.
 
59
*/
 
60
 
 
61
 
 
62
static PyObject *
 
63
gl_qread(PyObject *self, PyObject *args)
 
64
{
 
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
        }
 
76
}
 
77
 
 
78
 
 
79
/*
 
80
varray -- an array of v.. calls.
 
81
The argument is an array (maybe list or tuple) of points.
 
82
Each point must be a tuple or list of coordinates (x, y, z).
 
83
The points may be 2- or 3-dimensional but must all have the
 
84
same dimension.  Float and int values may be mixed however.
 
85
The points are always converted to 3D double precision points
 
86
by assuming z=0.0 if necessary (as indicated in the man page),
 
87
and for each point v3d() is called.
 
88
*/
 
89
 
 
90
 
 
91
static PyObject *
 
92
gl_varray(PyObject *self, PyObject *args)
 
93
{
 
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;
 
152
}
 
153
 
 
154
/*
 
155
vnarray, nvarray -- an array of n3f and v3f calls.
 
156
The argument is an array (list or tuple) of pairs of points and normals.
 
157
Each pair is a tuple (NOT a list) of a point and a normal for that point.
 
158
Each point or normal must be a tuple (NOT a list) of coordinates (x, y, z).
 
159
Three coordinates must be given.  Float and int values may be mixed.
 
160
For each pair, n3f() is called for the normal, and then v3f() is called
 
161
for the vector.
 
162
 
 
163
vnarray and nvarray differ only in the order of the vector and normal in
 
164
the pair: vnarray expects (v, n) while nvarray expects (n, v).
 
165
*/
 
166
 
 
167
static PyObject *gen_nvarray(); /* Forward */
 
168
 
 
169
 
 
170
static PyObject *
 
171
gl_nvarray(PyObject *self, PyObject *args)
 
172
{
 
173
        return gen_nvarray(args, 0);
 
174
}
 
175
 
 
176
 
 
177
static PyObject *
 
178
gl_vnarray(PyObject *self, PyObject *args)
 
179
{
 
180
        return gen_nvarray(args, 1);
 
181
}
 
182
 
 
183
/* Generic, internal version of {nv,nv}array: inorm indicates the
 
184
   argument order, 0: normal first, 1: vector first. */
 
185
 
 
186
static PyObject *
 
187
gen_nvarray(PyObject *args, int inorm)
 
188
{
 
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;
 
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
 
 
235
static PyObject *
 
236
gl_nurbssurface(PyObject *self, PyObject *args)
 
237
{
 
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;
 
315
}
 
316
 
 
317
/* nurbscurve(knots, ctlpoints, order, type).
 
318
   The length of ctlpoints is len(knots)-order. */
 
319
 
 
320
 
 
321
static PyObject *
 
322
gl_nurbscurve(PyObject *self, PyObject *args)
 
323
{
 
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;
 
375
}
 
376
 
 
377
/* pwlcurve(points, type).
 
378
   Points is a list of points. Type must be N_ST. */
 
379
 
 
380
 
 
381
static PyObject *
 
382
gl_pwlcurve(PyObject *self, PyObject *args)
 
383
{
 
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;
 
417
}
 
418
 
 
419
 
 
420
/* Picking and Selecting */
 
421
 
 
422
static short *pickbuffer = NULL;
 
423
static long pickbuffersize;
 
424
 
 
425
static PyObject *
 
426
pick_select(PyObject *args, void (*func)())
 
427
{
 
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;
 
441
}
 
442
 
 
443
static PyObject *
 
444
endpick_select(long (*func)())
 
445
{
 
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;
 
478
}
 
479
 
 
480
extern void pick(), gselect();
 
481
extern long endpick(), endselect();
 
482
 
 
483
static PyObject *gl_pick(PyObject *self, PyObject *args)
 
484
{
 
485
        return pick_select(args, pick);
 
486
}
 
487
 
 
488
static PyObject *gl_endpick(PyObject *self)
 
489
{
 
490
        return endpick_select(endpick);
 
491
}
 
492
 
 
493
static PyObject *gl_gselect(PyObject *self, PyObject *args)
 
494
{
 
495
        return pick_select(args, gselect);
 
496
}
 
497
 
 
498
static PyObject *gl_endselect(PyObject *self)
 
499
{
 
500
        return endpick_select(endselect);
 
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
 
 
509
static PyObject *
 
510
gl_getmatrix(PyObject *self, PyObject *args)
 
511
{
 
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;
 
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
 
 
536
static PyObject *
 
537
gl_altgetmatrix(PyObject *self, PyObject *args)
 
538
{
 
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;
 
566
}
 
567
 
 
568
 
 
569
static PyObject *
 
570
gl_lrectwrite(PyObject *self, PyObject *args)
 
571
{
 
572
        short x1 ;
 
573
        short y1 ;
 
574
        short x2 ;
 
575
        short y2 ;
 
576
        string parray ;
 
577
        PyObject *s;
 
578
#if 0
 
579
        int pixcount;
 
580
#endif
 
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;
 
593
#if 0
 
594
/* Don't check this, it breaks experiments with pixmode(PM_SIZE, ...) */
 
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
        }
 
601
#endif
 
602
        lrectwrite( x1 , y1 , x2 , y2 , (unsigned long *) parray );
 
603
        Py_INCREF(Py_None);
 
604
        return Py_None;
 
605
}
 
606
 
 
607
 
 
608
static PyObject *
 
609
gl_lrectread(PyObject *self, PyObject *args)
 
610
{
 
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;
 
631
}
 
632
 
 
633
 
 
634
static PyObject *
 
635
gl_readdisplay(PyObject *self, PyObject *args)
 
636
{
 
637
        short x1, y1, x2, y2;
 
638
        unsigned long *parray, hints;
 
639
        long size, size_ret;
 
640
        PyObject *rv;
 
641
 
 
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;
 
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
 
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
 
667
 
 
668
   gl.unpackrect(width, height, packfactor, smalldata) --> bigdata
 
669
                is the inverse; the numeric arguments must be *the same*.
 
670
 
 
671
   Both work best if width and height are multiples of packfactor
 
672
   (in fact unpackrect will leave garbage bytes).
 
673
*/
 
674
 
 
675
 
 
676
static PyObject *
 
677
gl_packrect(PyObject *self, PyObject *args)
 
678
{
 
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;
 
723
}
 
724
 
 
725
 
 
726
static unsigned long unpacktab[256];
 
727
static int unpacktab_inited = 0;
 
728
 
 
729
static PyObject *
 
730
gl_unpackrect(PyObject *self, PyObject *args)
 
731
{
 
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;
 
795
}
 
796
 
 
797
static PyObject *
 
798
gl_gversion(PyObject *self, PyObject *args)
 
799
{
 
800
        char buf[20];
 
801
        gversion(buf);
 
802
        return PyString_FromString(buf);
 
803
}
 
804
 
 
805
 
 
806
/* void clear - Manual because of clash with termcap */
 
807
static PyObject *
 
808
gl_clear(PyObject *self, PyObject *args)
 
809
{
 
810
        __GLclear( );
 
811
        Py_INCREF(Py_None);
 
812
        return Py_None;
 
813
}
 
814
 
 
815
/* End of manually written stubs */
 
816
 
 
817
 
 
818
/* long getshade */
 
819
 
 
820
static PyObject *
 
821
gl_getshade(PyObject *self, PyObject *args)
 
822
{
 
823
        long retval;
 
824
        retval = getshade( );
 
825
        return mknewlongobject(retval);
 
826
}
 
827
 
 
828
/* void devport short s long s */
 
829
 
 
830
static PyObject *
 
831
gl_devport(PyObject *self, PyObject *args)
 
832
{
 
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;
 
842
}
 
843
 
 
844
/* void rdr2i long s long s */
 
845
 
 
846
static PyObject *
 
847
gl_rdr2i(PyObject *self, PyObject *args)
 
848
{
 
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;
 
858
}
 
859
 
 
860
/* void rectfs short s short s short s short s */
 
861
 
 
862
static PyObject *
 
863
gl_rectfs(PyObject *self, PyObject *args)
 
864
{
 
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;
 
880
}
 
881
 
 
882
/* void rects short s short s short s short s */
 
883
 
 
884
static PyObject *
 
885
gl_rects(PyObject *self, PyObject *args)
 
886
{
 
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;
 
902
}
 
903
 
 
904
/* void rmv2i long s long s */
 
905
 
 
906
static PyObject *
 
907
gl_rmv2i(PyObject *self, PyObject *args)
 
908
{
 
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;
 
918
}
 
919
 
 
920
/* void noport */
 
921
 
 
922
static PyObject *
 
923
gl_noport(PyObject *self, PyObject *args)
 
924
{
 
925
        noport( );
 
926
        Py_INCREF(Py_None);
 
927
        return Py_None;
 
928
}
 
929
 
 
930
/* void popviewport */
 
931
 
 
932
static PyObject *
 
933
gl_popviewport(PyObject *self, PyObject *args)
 
934
{
 
935
        popviewport( );
 
936
        Py_INCREF(Py_None);
 
937
        return Py_None;
 
938
}
 
939
 
 
940
/* void clearhitcode */
 
941
 
 
942
static PyObject *
 
943
gl_clearhitcode(PyObject *self, PyObject *args)
 
944
{
 
945
        clearhitcode( );
 
946
        Py_INCREF(Py_None);
 
947
        return Py_None;
 
948
}
 
949
 
 
950
/* void closeobj */
 
951
 
 
952
static PyObject *
 
953
gl_closeobj(PyObject *self, PyObject *args)
 
954
{
 
955
        closeobj( );
 
956
        Py_INCREF(Py_None);
 
957
        return Py_None;
 
958
}
 
959
 
 
960
/* void cursoff */
 
961
 
 
962
static PyObject *
 
963
gl_cursoff(PyObject *self, PyObject *args)
 
964
{
 
965
        cursoff( );
 
966
        Py_INCREF(Py_None);
 
967
        return Py_None;
 
968
}
 
969
 
 
970
/* void curson */
 
971
 
 
972
static PyObject *
 
973
gl_curson(PyObject *self, PyObject *args)
 
974
{
 
975
        curson( );
 
976
        Py_INCREF(Py_None);
 
977
        return Py_None;
 
978
}
 
979
 
 
980
/* void doublebuffer */
 
981
 
 
982
static PyObject *
 
983
gl_doublebuffer(PyObject *self, PyObject *args)
 
984
{
 
985
        doublebuffer( );
 
986
        Py_INCREF(Py_None);
 
987
        return Py_None;
 
988
}
 
989
 
 
990
/* void finish */
 
991
 
 
992
static PyObject *
 
993
gl_finish(PyObject *self, PyObject *args)
 
994
{
 
995
        finish( );
 
996
        Py_INCREF(Py_None);
 
997
        return Py_None;
 
998
}
 
999
 
 
1000
/* void gconfig */
 
1001
 
 
1002
static PyObject *
 
1003
gl_gconfig(PyObject *self, PyObject *args)
 
1004
{
 
1005
        gconfig( );
 
1006
        Py_INCREF(Py_None);
 
1007
        return Py_None;
 
1008
}
 
1009
 
 
1010
/* void ginit */
 
1011
 
 
1012
static PyObject *
 
1013
gl_ginit(PyObject *self, PyObject *args)
 
1014
{
 
1015
        ginit( );
 
1016
        Py_INCREF(Py_None);
 
1017
        return Py_None;
 
1018
}
 
1019
 
 
1020
/* void greset */
 
1021
 
 
1022
static PyObject *
 
1023
gl_greset(PyObject *self, PyObject *args)
 
1024
{
 
1025
        greset( );
 
1026
        Py_INCREF(Py_None);
 
1027
        return Py_None;
 
1028
}
 
1029
 
 
1030
/* void multimap */
 
1031
 
 
1032
static PyObject *
 
1033
gl_multimap(PyObject *self, PyObject *args)
 
1034
{
 
1035
        multimap( );
 
1036
        Py_INCREF(Py_None);
 
1037
        return Py_None;
 
1038
}
 
1039
 
 
1040
/* void onemap */
 
1041
 
 
1042
static PyObject *
 
1043
gl_onemap(PyObject *self, PyObject *args)
 
1044
{
 
1045
        onemap( );
 
1046
        Py_INCREF(Py_None);
 
1047
        return Py_None;
 
1048
}
 
1049
 
 
1050
/* void popattributes */
 
1051
 
 
1052
static PyObject *
 
1053
gl_popattributes(PyObject *self, PyObject *args)
 
1054
{
 
1055
        popattributes( );
 
1056
        Py_INCREF(Py_None);
 
1057
        return Py_None;
 
1058
}
 
1059
 
 
1060
/* void popmatrix */
 
1061
 
 
1062
static PyObject *
 
1063
gl_popmatrix(PyObject *self, PyObject *args)
 
1064
{
 
1065
        popmatrix( );
 
1066
        Py_INCREF(Py_None);
 
1067
        return Py_None;
 
1068
}
 
1069
 
 
1070
/* void pushattributes */
 
1071
 
 
1072
static PyObject *
 
1073
gl_pushattributes(PyObject *self, PyObject *args)
 
1074
{
 
1075
        pushattributes( );
 
1076
        Py_INCREF(Py_None);
 
1077
        return Py_None;
 
1078
}
 
1079
 
 
1080
/* void pushmatrix */
 
1081
 
 
1082
static PyObject *
 
1083
gl_pushmatrix(PyObject *self, PyObject *args)
 
1084
{
 
1085
        pushmatrix( );
 
1086
        Py_INCREF(Py_None);
 
1087
        return Py_None;
 
1088
}
 
1089
 
 
1090
/* void pushviewport */
 
1091
 
 
1092
static PyObject *
 
1093
gl_pushviewport(PyObject *self, PyObject *args)
 
1094
{
 
1095
        pushviewport( );
 
1096
        Py_INCREF(Py_None);
 
1097
        return Py_None;
 
1098
}
 
1099
 
 
1100
/* void qreset */
 
1101
 
 
1102
static PyObject *
 
1103
gl_qreset(PyObject *self, PyObject *args)
 
1104
{
 
1105
        qreset( );
 
1106
        Py_INCREF(Py_None);
 
1107
        return Py_None;
 
1108
}
 
1109
 
 
1110
/* void RGBmode */
 
1111
 
 
1112
static PyObject *
 
1113
gl_RGBmode(PyObject *self, PyObject *args)
 
1114
{
 
1115
        RGBmode( );
 
1116
        Py_INCREF(Py_None);
 
1117
        return Py_None;
 
1118
}
 
1119
 
 
1120
/* void singlebuffer */
 
1121
 
 
1122
static PyObject *
 
1123
gl_singlebuffer(PyObject *self, PyObject *args)
 
1124
{
 
1125
        singlebuffer( );
 
1126
        Py_INCREF(Py_None);
 
1127
        return Py_None;
 
1128
}
 
1129
 
 
1130
/* void swapbuffers */
 
1131
 
 
1132
static PyObject *
 
1133
gl_swapbuffers(PyObject *self, PyObject *args)
 
1134
{
 
1135
        swapbuffers( );
 
1136
        Py_INCREF(Py_None);
 
1137
        return Py_None;
 
1138
}
 
1139
 
 
1140
/* void gsync */
 
1141
 
 
1142
static PyObject *
 
1143
gl_gsync(PyObject *self, PyObject *args)
 
1144
{
 
1145
        gsync( );
 
1146
        Py_INCREF(Py_None);
 
1147
        return Py_None;
 
1148
}
 
1149
 
 
1150
/* void gflush */
 
1151
 
 
1152
static PyObject *
 
1153
gl_gflush(PyObject *self, PyObject *args)
 
1154
{
 
1155
        gflush( );
 
1156
        Py_INCREF(Py_None);
 
1157
        return Py_None;
 
1158
}
 
1159
 
 
1160
/* void tpon */
 
1161
 
 
1162
static PyObject *
 
1163
gl_tpon(PyObject *self, PyObject *args)
 
1164
{
 
1165
        tpon( );
 
1166
        Py_INCREF(Py_None);
 
1167
        return Py_None;
 
1168
}
 
1169
 
 
1170
/* void tpoff */
 
1171
 
 
1172
static PyObject *
 
1173
gl_tpoff(PyObject *self, PyObject *args)
 
1174
{
 
1175
        tpoff( );
 
1176
        Py_INCREF(Py_None);
 
1177
        return Py_None;
 
1178
}
 
1179
 
 
1180
/* void clkon */
 
1181
 
 
1182
static PyObject *
 
1183
gl_clkon(PyObject *self, PyObject *args)
 
1184
{
 
1185
        clkon( );
 
1186
        Py_INCREF(Py_None);
 
1187
        return Py_None;
 
1188
}
 
1189
 
 
1190
/* void clkoff */
 
1191
 
 
1192
static PyObject *
 
1193
gl_clkoff(PyObject *self, PyObject *args)
 
1194
{
 
1195
        clkoff( );
 
1196
        Py_INCREF(Py_None);
 
1197
        return Py_None;
 
1198
}
 
1199
 
 
1200
/* void ringbell */
 
1201
 
 
1202
static PyObject *
 
1203
gl_ringbell(PyObject *self, PyObject *args)
 
1204
{
 
1205
        ringbell( );
 
1206
        Py_INCREF(Py_None);
 
1207
        return Py_None;
 
1208
}
 
1209
 
 
1210
/* void gbegin */
 
1211
 
 
1212
static PyObject *
 
1213
gl_gbegin(PyObject *self, PyObject *args)
 
1214
{
 
1215
        gbegin( );
 
1216
        Py_INCREF(Py_None);
 
1217
        return Py_None;
 
1218
}
 
1219
 
 
1220
/* void textinit */
 
1221
 
 
1222
static PyObject *
 
1223
gl_textinit(PyObject *self, PyObject *args)
 
1224
{
 
1225
        textinit( );
 
1226
        Py_INCREF(Py_None);
 
1227
        return Py_None;
 
1228
}
 
1229
 
 
1230
/* void initnames */
 
1231
 
 
1232
static PyObject *
 
1233
gl_initnames(PyObject *self, PyObject *args)
 
1234
{
 
1235
        initnames( );
 
1236
        Py_INCREF(Py_None);
 
1237
        return Py_None;
 
1238
}
 
1239
 
 
1240
/* void pclos */
 
1241
 
 
1242
static PyObject *
 
1243
gl_pclos(PyObject *self, PyObject *args)
 
1244
{
 
1245
        pclos( );
 
1246
        Py_INCREF(Py_None);
 
1247
        return Py_None;
 
1248
}
 
1249
 
 
1250
/* void popname */
 
1251
 
 
1252
static PyObject *
 
1253
gl_popname(PyObject *self, PyObject *args)
 
1254
{
 
1255
        popname( );
 
1256
        Py_INCREF(Py_None);
 
1257
        return Py_None;
 
1258
}
 
1259
 
 
1260
/* void spclos */
 
1261
 
 
1262
static PyObject *
 
1263
gl_spclos(PyObject *self, PyObject *args)
 
1264
{
 
1265
        spclos( );
 
1266
        Py_INCREF(Py_None);
 
1267
        return Py_None;
 
1268
}
 
1269
 
 
1270
/* void zclear */
 
1271
 
 
1272
static PyObject *
 
1273
gl_zclear(PyObject *self, PyObject *args)
 
1274
{
 
1275
        zclear( );
 
1276
        Py_INCREF(Py_None);
 
1277
        return Py_None;
 
1278
}
 
1279
 
 
1280
/* void screenspace */
 
1281
 
 
1282
static PyObject *
 
1283
gl_screenspace(PyObject *self, PyObject *args)
 
1284
{
 
1285
        screenspace( );
 
1286
        Py_INCREF(Py_None);
 
1287
        return Py_None;
 
1288
}
 
1289
 
 
1290
/* void reshapeviewport */
 
1291
 
 
1292
static PyObject *
 
1293
gl_reshapeviewport(PyObject *self, PyObject *args)
 
1294
{
 
1295
        reshapeviewport( );
 
1296
        Py_INCREF(Py_None);
 
1297
        return Py_None;
 
1298
}
 
1299
 
 
1300
/* void winpush */
 
1301
 
 
1302
static PyObject *
 
1303
gl_winpush(PyObject *self, PyObject *args)
 
1304
{
 
1305
        winpush( );
 
1306
        Py_INCREF(Py_None);
 
1307
        return Py_None;
 
1308
}
 
1309
 
 
1310
/* void winpop */
 
1311
 
 
1312
static PyObject *
 
1313
gl_winpop(PyObject *self, PyObject *args)
 
1314
{
 
1315
        winpop( );
 
1316
        Py_INCREF(Py_None);
 
1317
        return Py_None;
 
1318
}
 
1319
 
 
1320
/* void foreground */
 
1321
 
 
1322
static PyObject *
 
1323
gl_foreground(PyObject *self, PyObject *args)
 
1324
{
 
1325
        foreground( );
 
1326
        Py_INCREF(Py_None);
 
1327
        return Py_None;
 
1328
}
 
1329
 
 
1330
/* void endfullscrn */
 
1331
 
 
1332
static PyObject *
 
1333
gl_endfullscrn(PyObject *self, PyObject *args)
 
1334
{
 
1335
        endfullscrn( );
 
1336
        Py_INCREF(Py_None);
 
1337
        return Py_None;
 
1338
}
 
1339
 
 
1340
/* void endpupmode */
 
1341
 
 
1342
static PyObject *
 
1343
gl_endpupmode(PyObject *self, PyObject *args)
 
1344
{
 
1345
        endpupmode( );
 
1346
        Py_INCREF(Py_None);
 
1347
        return Py_None;
 
1348
}
 
1349
 
 
1350
/* void fullscrn */
 
1351
 
 
1352
static PyObject *
 
1353
gl_fullscrn(PyObject *self, PyObject *args)
 
1354
{
 
1355
        fullscrn( );
 
1356
        Py_INCREF(Py_None);
 
1357
        return Py_None;
 
1358
}
 
1359
 
 
1360
/* void pupmode */
 
1361
 
 
1362
static PyObject *
 
1363
gl_pupmode(PyObject *self, PyObject *args)
 
1364
{
 
1365
        pupmode( );
 
1366
        Py_INCREF(Py_None);
 
1367
        return Py_None;
 
1368
}
 
1369
 
 
1370
/* void winconstraints */
 
1371
 
 
1372
static PyObject *
 
1373
gl_winconstraints(PyObject *self, PyObject *args)
 
1374
{
 
1375
        winconstraints( );
 
1376
        Py_INCREF(Py_None);
 
1377
        return Py_None;
 
1378
}
 
1379
 
 
1380
/* void pagecolor short s */
 
1381
 
 
1382
static PyObject *
 
1383
gl_pagecolor(PyObject *self, PyObject *args)
 
1384
{
 
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;
 
1391
}
 
1392
 
 
1393
/* void textcolor short s */
 
1394
 
 
1395
static PyObject *
 
1396
gl_textcolor(PyObject *self, PyObject *args)
 
1397
{
 
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;
 
1404
}
 
1405
 
 
1406
/* void color short s */
 
1407
 
 
1408
static PyObject *
 
1409
gl_color(PyObject *self, PyObject *args)
 
1410
{
 
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;
 
1417
}
 
1418
 
 
1419
/* void curveit short s */
 
1420
 
 
1421
static PyObject *
 
1422
gl_curveit(PyObject *self, PyObject *args)
 
1423
{
 
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;
 
1430
}
 
1431
 
 
1432
/* void font short s */
 
1433
 
 
1434
static PyObject *
 
1435
gl_font(PyObject *self, PyObject *args)
 
1436
{
 
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;
 
1443
}
 
1444
 
 
1445
/* void linewidth short s */
 
1446
 
 
1447
static PyObject *
 
1448
gl_linewidth(PyObject *self, PyObject *args)
 
1449
{
 
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;
 
1456
}
 
1457
 
 
1458
/* void setlinestyle short s */
 
1459
 
 
1460
static PyObject *
 
1461
gl_setlinestyle(PyObject *self, PyObject *args)
 
1462
{
 
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;
 
1469
}
 
1470
 
 
1471
/* void setmap short s */
 
1472
 
 
1473
static PyObject *
 
1474
gl_setmap(PyObject *self, PyObject *args)
 
1475
{
 
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;
 
1482
}
 
1483
 
 
1484
/* void swapinterval short s */
 
1485
 
 
1486
static PyObject *
 
1487
gl_swapinterval(PyObject *self, PyObject *args)
 
1488
{
 
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;
 
1495
}
 
1496
 
 
1497
/* void writemask short s */
 
1498
 
 
1499
static PyObject *
 
1500
gl_writemask(PyObject *self, PyObject *args)
 
1501
{
 
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;
 
1508
}
 
1509
 
 
1510
/* void textwritemask short s */
 
1511
 
 
1512
static PyObject *
 
1513
gl_textwritemask(PyObject *self, PyObject *args)
 
1514
{
 
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;
 
1521
}
 
1522
 
 
1523
/* void qdevice short s */
 
1524
 
 
1525
static PyObject *
 
1526
gl_qdevice(PyObject *self, PyObject *args)
 
1527
{
 
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;
 
1534
}
 
1535
 
 
1536
/* void unqdevice short s */
 
1537
 
 
1538
static PyObject *
 
1539
gl_unqdevice(PyObject *self, PyObject *args)
 
1540
{
 
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;
 
1547
}
 
1548
 
 
1549
/* void curvebasis short s */
 
1550
 
 
1551
static PyObject *
 
1552
gl_curvebasis(PyObject *self, PyObject *args)
 
1553
{
 
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;
 
1560
}
 
1561
 
 
1562
/* void curveprecision short s */
 
1563
 
 
1564
static PyObject *
 
1565
gl_curveprecision(PyObject *self, PyObject *args)
 
1566
{
 
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;
 
1573
}
 
1574
 
 
1575
/* void loadname short s */
 
1576
 
 
1577
static PyObject *
 
1578
gl_loadname(PyObject *self, PyObject *args)
 
1579
{
 
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;
 
1586
}
 
1587
 
 
1588
/* void passthrough short s */
 
1589
 
 
1590
static PyObject *
 
1591
gl_passthrough(PyObject *self, PyObject *args)
 
1592
{
 
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;
 
1599
}
 
1600
 
 
1601
/* void pushname short s */
 
1602
 
 
1603
static PyObject *
 
1604
gl_pushname(PyObject *self, PyObject *args)
 
1605
{
 
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;
 
1612
}
 
1613
 
 
1614
/* void setmonitor short s */
 
1615
 
 
1616
static PyObject *
 
1617
gl_setmonitor(PyObject *self, PyObject *args)
 
1618
{
 
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;
 
1625
}
 
1626
 
 
1627
/* void setshade short s */
 
1628
 
 
1629
static PyObject *
 
1630
gl_setshade(PyObject *self, PyObject *args)
 
1631
{
 
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;
 
1638
}
 
1639
 
 
1640
/* void setpattern short s */
 
1641
 
 
1642
static PyObject *
 
1643
gl_setpattern(PyObject *self, PyObject *args)
 
1644
{
 
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;
 
1651
}
 
1652
 
 
1653
/* void pagewritemask short s */
 
1654
 
 
1655
static PyObject *
 
1656
gl_pagewritemask(PyObject *self, PyObject *args)
 
1657
{
 
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;
 
1664
}
 
1665
 
 
1666
/* void callobj long s */
 
1667
 
 
1668
static PyObject *
 
1669
gl_callobj(PyObject *self, PyObject *args)
 
1670
{
 
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;
 
1677
}
 
1678
 
 
1679
/* void delobj long s */
 
1680
 
 
1681
static PyObject *
 
1682
gl_delobj(PyObject *self, PyObject *args)
 
1683
{
 
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;
 
1690
}
 
1691
 
 
1692
/* void editobj long s */
 
1693
 
 
1694
static PyObject *
 
1695
gl_editobj(PyObject *self, PyObject *args)
 
1696
{
 
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;
 
1703
}
 
1704
 
 
1705
/* void makeobj long s */
 
1706
 
 
1707
static PyObject *
 
1708
gl_makeobj(PyObject *self, PyObject *args)
 
1709
{
 
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;
 
1716
}
 
1717
 
 
1718
/* void maketag long s */
 
1719
 
 
1720
static PyObject *
 
1721
gl_maketag(PyObject *self, PyObject *args)
 
1722
{
 
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;
 
1729
}
 
1730
 
 
1731
/* void chunksize long s */
 
1732
 
 
1733
static PyObject *
 
1734
gl_chunksize(PyObject *self, PyObject *args)
 
1735
{
 
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;
 
1742
}
 
1743
 
 
1744
/* void compactify long s */
 
1745
 
 
1746
static PyObject *
 
1747
gl_compactify(PyObject *self, PyObject *args)
 
1748
{
 
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;
 
1755
}
 
1756
 
 
1757
/* void deltag long s */
 
1758
 
 
1759
static PyObject *
 
1760
gl_deltag(PyObject *self, PyObject *args)
 
1761
{
 
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;
 
1768
}
 
1769
 
 
1770
/* void lsrepeat long s */
 
1771
 
 
1772
static PyObject *
 
1773
gl_lsrepeat(PyObject *self, PyObject *args)
 
1774
{
 
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;
 
1781
}
 
1782
 
 
1783
/* void objinsert long s */
 
1784
 
 
1785
static PyObject *
 
1786
gl_objinsert(PyObject *self, PyObject *args)
 
1787
{
 
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;
 
1794
}
 
1795
 
 
1796
/* void objreplace long s */
 
1797
 
 
1798
static PyObject *
 
1799
gl_objreplace(PyObject *self, PyObject *args)
 
1800
{
 
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;
 
1807
}
 
1808
 
 
1809
/* void winclose long s */
 
1810
 
 
1811
static PyObject *
 
1812
gl_winclose(PyObject *self, PyObject *args)
 
1813
{
 
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;
 
1820
}
 
1821
 
 
1822
/* void blanktime long s */
 
1823
 
 
1824
static PyObject *
 
1825
gl_blanktime(PyObject *self, PyObject *args)
 
1826
{
 
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;
 
1833
}
 
1834
 
 
1835
/* void freepup long s */
 
1836
 
 
1837
static PyObject *
 
1838
gl_freepup(PyObject *self, PyObject *args)
 
1839
{
 
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;
 
1846
}
 
1847
 
 
1848
/* void backbuffer long s */
 
1849
 
 
1850
static PyObject *
 
1851
gl_backbuffer(PyObject *self, PyObject *args)
 
1852
{
 
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;
 
1859
}
 
1860
 
 
1861
/* void frontbuffer long s */
 
1862
 
 
1863
static PyObject *
 
1864
gl_frontbuffer(PyObject *self, PyObject *args)
 
1865
{
 
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;
 
1872
}
 
1873
 
 
1874
/* void lsbackup long s */
 
1875
 
 
1876
static PyObject *
 
1877
gl_lsbackup(PyObject *self, PyObject *args)
 
1878
{
 
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;
 
1885
}
 
1886
 
 
1887
/* void resetls long s */
 
1888
 
 
1889
static PyObject *
 
1890
gl_resetls(PyObject *self, PyObject *args)
 
1891
{
 
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;
 
1898
}
 
1899
 
 
1900
/* void lampon long s */
 
1901
 
 
1902
static PyObject *
 
1903
gl_lampon(PyObject *self, PyObject *args)
 
1904
{
 
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;
 
1911
}
 
1912
 
 
1913
/* void lampoff long s */
 
1914
 
 
1915
static PyObject *
 
1916
gl_lampoff(PyObject *self, PyObject *args)
 
1917
{
 
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;
 
1924
}
 
1925
 
 
1926
/* void setbell long s */
 
1927
 
 
1928
static PyObject *
 
1929
gl_setbell(PyObject *self, PyObject *args)
 
1930
{
 
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;
 
1937
}
 
1938
 
 
1939
/* void blankscreen long s */
 
1940
 
 
1941
static PyObject *
 
1942
gl_blankscreen(PyObject *self, PyObject *args)
 
1943
{
 
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;
 
1950
}
 
1951
 
 
1952
/* void depthcue long s */
 
1953
 
 
1954
static PyObject *
 
1955
gl_depthcue(PyObject *self, PyObject *args)
 
1956
{
 
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;
 
1963
}
 
1964
 
 
1965
/* void zbuffer long s */
 
1966
 
 
1967
static PyObject *
 
1968
gl_zbuffer(PyObject *self, PyObject *args)
 
1969
{
 
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;
 
1976
}
 
1977
 
 
1978
/* void backface long s */
 
1979
 
 
1980
static PyObject *
 
1981
gl_backface(PyObject *self, PyObject *args)
 
1982
{
 
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;
 
1989
}
 
1990
 
 
1991
/* void cmov2i long s long s */
 
1992
 
 
1993
static PyObject *
 
1994
gl_cmov2i(PyObject *self, PyObject *args)
 
1995
{
 
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;
 
2005
}
 
2006
 
 
2007
/* void draw2i long s long s */
 
2008
 
 
2009
static PyObject *
 
2010
gl_draw2i(PyObject *self, PyObject *args)
 
2011
{
 
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;
 
2021
}
 
2022
 
 
2023
/* void move2i long s long s */
 
2024
 
 
2025
static PyObject *
 
2026
gl_move2i(PyObject *self, PyObject *args)
 
2027
{
 
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;
 
2037
}
 
2038
 
 
2039
/* void pnt2i long s long s */
 
2040
 
 
2041
static PyObject *
 
2042
gl_pnt2i(PyObject *self, PyObject *args)
 
2043
{
 
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;
 
2053
}
 
2054
 
 
2055
/* void patchbasis long s long s */
 
2056
 
 
2057
static PyObject *
 
2058
gl_patchbasis(PyObject *self, PyObject *args)
 
2059
{
 
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;
 
2069
}
 
2070
 
 
2071
/* void patchprecision long s long s */
 
2072
 
 
2073
static PyObject *
 
2074
gl_patchprecision(PyObject *self, PyObject *args)
 
2075
{
 
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;
 
2085
}
 
2086
 
 
2087
/* void pdr2i long s long s */
 
2088
 
 
2089
static PyObject *
 
2090
gl_pdr2i(PyObject *self, PyObject *args)
 
2091
{
 
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;
 
2101
}
 
2102
 
 
2103
/* void pmv2i long s long s */
 
2104
 
 
2105
static PyObject *
 
2106
gl_pmv2i(PyObject *self, PyObject *args)
 
2107
{
 
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;
 
2117
}
 
2118
 
 
2119
/* void rpdr2i long s long s */
 
2120
 
 
2121
static PyObject *
 
2122
gl_rpdr2i(PyObject *self, PyObject *args)
 
2123
{
 
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;
 
2133
}
 
2134
 
 
2135
/* void rpmv2i long s long s */
 
2136
 
 
2137
static PyObject *
 
2138
gl_rpmv2i(PyObject *self, PyObject *args)
 
2139
{
 
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;
 
2149
}
 
2150
 
 
2151
/* void xfpt2i long s long s */
 
2152
 
 
2153
static PyObject *
 
2154
gl_xfpt2i(PyObject *self, PyObject *args)
 
2155
{
 
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;
 
2165
}
 
2166
 
 
2167
/* void objdelete long s long s */
 
2168
 
 
2169
static PyObject *
 
2170
gl_objdelete(PyObject *self, PyObject *args)
 
2171
{
 
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;
 
2181
}
 
2182
 
 
2183
/* void patchcurves long s long s */
 
2184
 
 
2185
static PyObject *
 
2186
gl_patchcurves(PyObject *self, PyObject *args)
 
2187
{
 
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;
 
2197
}
 
2198
 
 
2199
/* void minsize long s long s */
 
2200
 
 
2201
static PyObject *
 
2202
gl_minsize(PyObject *self, PyObject *args)
 
2203
{
 
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;
 
2213
}
 
2214
 
 
2215
/* void maxsize long s long s */
 
2216
 
 
2217
static PyObject *
 
2218
gl_maxsize(PyObject *self, PyObject *args)
 
2219
{
 
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;
 
2229
}
 
2230
 
 
2231
/* void keepaspect long s long s */
 
2232
 
 
2233
static PyObject *
 
2234
gl_keepaspect(PyObject *self, PyObject *args)
 
2235
{
 
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;
 
2245
}
 
2246
 
 
2247
/* void prefsize long s long s */
 
2248
 
 
2249
static PyObject *
 
2250
gl_prefsize(PyObject *self, PyObject *args)
 
2251
{
 
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;
 
2261
}
 
2262
 
 
2263
/* void stepunit long s long s */
 
2264
 
 
2265
static PyObject *
 
2266
gl_stepunit(PyObject *self, PyObject *args)
 
2267
{
 
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;
 
2277
}
 
2278
 
 
2279
/* void fudge long s long s */
 
2280
 
 
2281
static PyObject *
 
2282
gl_fudge(PyObject *self, PyObject *args)
 
2283
{
 
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;
 
2293
}
 
2294
 
 
2295
/* void winmove long s long s */
 
2296
 
 
2297
static PyObject *
 
2298
gl_winmove(PyObject *self, PyObject *args)
 
2299
{
 
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;
 
2309
}
 
2310
 
 
2311
/* void attachcursor short s short s */
 
2312
 
 
2313
static PyObject *
 
2314
gl_attachcursor(PyObject *self, PyObject *args)
 
2315
{
 
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;
 
2325
}
 
2326
 
 
2327
/* void deflinestyle short s short s */
 
2328
 
 
2329
static PyObject *
 
2330
gl_deflinestyle(PyObject *self, PyObject *args)
 
2331
{
 
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;
 
2341
}
 
2342
 
 
2343
/* void noise short s short s */
 
2344
 
 
2345
static PyObject *
 
2346
gl_noise(PyObject *self, PyObject *args)
 
2347
{
 
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;
 
2357
}
 
2358
 
 
2359
/* void picksize short s short s */
 
2360
 
 
2361
static PyObject *
 
2362
gl_picksize(PyObject *self, PyObject *args)
 
2363
{
 
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;
 
2373
}
 
2374
 
 
2375
/* void qenter short s short s */
 
2376
 
 
2377
static PyObject *
 
2378
gl_qenter(PyObject *self, PyObject *args)
 
2379
{
 
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;
 
2389
}
 
2390
 
 
2391
/* void setdepth short s short s */
 
2392
 
 
2393
static PyObject *
 
2394
gl_setdepth(PyObject *self, PyObject *args)
 
2395
{
 
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;
 
2405
}
 
2406
 
 
2407
/* void cmov2s short s short s */
 
2408
 
 
2409
static PyObject *
 
2410
gl_cmov2s(PyObject *self, PyObject *args)
 
2411
{
 
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;
 
2421
}
 
2422
 
 
2423
/* void draw2s short s short s */
 
2424
 
 
2425
static PyObject *
 
2426
gl_draw2s(PyObject *self, PyObject *args)
 
2427
{
 
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;
 
2437
}
 
2438
 
 
2439
/* void move2s short s short s */
 
2440
 
 
2441
static PyObject *
 
2442
gl_move2s(PyObject *self, PyObject *args)
 
2443
{
 
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;
 
2453
}
 
2454
 
 
2455
/* void pdr2s short s short s */
 
2456
 
 
2457
static PyObject *
 
2458
gl_pdr2s(PyObject *self, PyObject *args)
 
2459
{
 
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;
 
2469
}
 
2470
 
 
2471
/* void pmv2s short s short s */
 
2472
 
 
2473
static PyObject *
 
2474
gl_pmv2s(PyObject *self, PyObject *args)
 
2475
{
 
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;
 
2485
}
 
2486
 
 
2487
/* void pnt2s short s short s */
 
2488
 
 
2489
static PyObject *
 
2490
gl_pnt2s(PyObject *self, PyObject *args)
 
2491
{
 
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;
 
2501
}
 
2502
 
 
2503
/* void rdr2s short s short s */
 
2504
 
 
2505
static PyObject *
 
2506
gl_rdr2s(PyObject *self, PyObject *args)
 
2507
{
 
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;
 
2517
}
 
2518
 
 
2519
/* void rmv2s short s short s */
 
2520
 
 
2521
static PyObject *
 
2522
gl_rmv2s(PyObject *self, PyObject *args)
 
2523
{
 
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;
 
2533
}
 
2534
 
 
2535
/* void rpdr2s short s short s */
 
2536
 
 
2537
static PyObject *
 
2538
gl_rpdr2s(PyObject *self, PyObject *args)
 
2539
{
 
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;
 
2549
}
 
2550
 
 
2551
/* void rpmv2s short s short s */
 
2552
 
 
2553
static PyObject *
 
2554
gl_rpmv2s(PyObject *self, PyObject *args)
 
2555
{
 
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;
 
2565
}
 
2566
 
 
2567
/* void xfpt2s short s short s */
 
2568
 
 
2569
static PyObject *
 
2570
gl_xfpt2s(PyObject *self, PyObject *args)
 
2571
{
 
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;
 
2581
}
 
2582
 
 
2583
/* void cmov2 float s float s */
 
2584
 
 
2585
static PyObject *
 
2586
gl_cmov2(PyObject *self, PyObject *args)
 
2587
{
 
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;
 
2597
}
 
2598
 
 
2599
/* void draw2 float s float s */
 
2600
 
 
2601
static PyObject *
 
2602
gl_draw2(PyObject *self, PyObject *args)
 
2603
{
 
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;
 
2613
}
 
2614
 
 
2615
/* void move2 float s float s */
 
2616
 
 
2617
static PyObject *
 
2618
gl_move2(PyObject *self, PyObject *args)
 
2619
{
 
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;
 
2629
}
 
2630
 
 
2631
/* void pnt2 float s float s */
 
2632
 
 
2633
static PyObject *
 
2634
gl_pnt2(PyObject *self, PyObject *args)
 
2635
{
 
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;
 
2645
}
 
2646
 
 
2647
/* void pdr2 float s float s */
 
2648
 
 
2649
static PyObject *
 
2650
gl_pdr2(PyObject *self, PyObject *args)
 
2651
{
 
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;
 
2661
}
 
2662
 
 
2663
/* void pmv2 float s float s */
 
2664
 
 
2665
static PyObject *
 
2666
gl_pmv2(PyObject *self, PyObject *args)
 
2667
{
 
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;
 
2677
}
 
2678
 
 
2679
/* void rdr2 float s float s */
 
2680
 
 
2681
static PyObject *
 
2682
gl_rdr2(PyObject *self, PyObject *args)
 
2683
{
 
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;
 
2693
}
 
2694
 
 
2695
/* void rmv2 float s float s */
 
2696
 
 
2697
static PyObject *
 
2698
gl_rmv2(PyObject *self, PyObject *args)
 
2699
{
 
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;
 
2709
}
 
2710
 
 
2711
/* void rpdr2 float s float s */
 
2712
 
 
2713
static PyObject *
 
2714
gl_rpdr2(PyObject *self, PyObject *args)
 
2715
{
 
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;
 
2725
}
 
2726
 
 
2727
/* void rpmv2 float s float s */
 
2728
 
 
2729
static PyObject *
 
2730
gl_rpmv2(PyObject *self, PyObject *args)
 
2731
{
 
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;
 
2741
}
 
2742
 
 
2743
/* void xfpt2 float s float s */
 
2744
 
 
2745
static PyObject *
 
2746
gl_xfpt2(PyObject *self, PyObject *args)
 
2747
{
 
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;
 
2757
}
 
2758
 
 
2759
/* void loadmatrix float s[4*4] */
 
2760
 
 
2761
static PyObject *
 
2762
gl_loadmatrix(PyObject *self, PyObject *args)
 
2763
{
 
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;
 
2770
}
 
2771
 
 
2772
/* void multmatrix float s[4*4] */
 
2773
 
 
2774
static PyObject *
 
2775
gl_multmatrix(PyObject *self, PyObject *args)
 
2776
{
 
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;
 
2783
}
 
2784
 
 
2785
/* void crv float s[3*4] */
 
2786
 
 
2787
static PyObject *
 
2788
gl_crv(PyObject *self, PyObject *args)
 
2789
{
 
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;
 
2796
}
 
2797
 
 
2798
/* void rcrv float s[4*4] */
 
2799
 
 
2800
static PyObject *
 
2801
gl_rcrv(PyObject *self, PyObject *args)
 
2802
{
 
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;
 
2809
}
 
2810
 
 
2811
/* void addtopup long s char *s long s */
 
2812
 
 
2813
static PyObject *
 
2814
gl_addtopup(PyObject *self, PyObject *args)
 
2815
{
 
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;
 
2828
}
 
2829
 
 
2830
/* void charstr char *s */
 
2831
 
 
2832
static PyObject *
 
2833
gl_charstr(PyObject *self, PyObject *args)
 
2834
{
 
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;
 
2841
}
 
2842
 
 
2843
/* void getport char *s */
 
2844
 
 
2845
static PyObject *
 
2846
gl_getport(PyObject *self, PyObject *args)
 
2847
{
 
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;
 
2854
}
 
2855
 
 
2856
/* long strwidth char *s */
 
2857
 
 
2858
static PyObject *
 
2859
gl_strwidth(PyObject *self, PyObject *args)
 
2860
{
 
2861
        long retval;
 
2862
        string arg1 ;
 
2863
        if (!getistringarg(args, 1, 0, &arg1))
 
2864
                return NULL;
 
2865
        retval = strwidth( arg1 );
 
2866
        return mknewlongobject(retval);
 
2867
}
 
2868
 
 
2869
/* long winopen char *s */
 
2870
 
 
2871
static PyObject *
 
2872
gl_winopen(PyObject *self, PyObject *args)
 
2873
{
 
2874
        long retval;
 
2875
        string arg1 ;
 
2876
        if (!getistringarg(args, 1, 0, &arg1))
 
2877
                return NULL;
 
2878
        retval = winopen( arg1 );
 
2879
        return mknewlongobject(retval);
 
2880
}
 
2881
 
 
2882
/* void wintitle char *s */
 
2883
 
 
2884
static PyObject *
 
2885
gl_wintitle(PyObject *self, PyObject *args)
 
2886
{
 
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;
 
2893
}
 
2894
 
 
2895
/* void polf long s float s[3*arg1] */
 
2896
 
 
2897
static PyObject *
 
2898
gl_polf(PyObject *self, PyObject *args)
 
2899
{
 
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;
 
2913
}
 
2914
 
 
2915
/* void polf2 long s float s[2*arg1] */
 
2916
 
 
2917
static PyObject *
 
2918
gl_polf2(PyObject *self, PyObject *args)
 
2919
{
 
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;
 
2933
}
 
2934
 
 
2935
/* void poly long s float s[3*arg1] */
 
2936
 
 
2937
static PyObject *
 
2938
gl_poly(PyObject *self, PyObject *args)
 
2939
{
 
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;
 
2953
}
 
2954
 
 
2955
/* void poly2 long s float s[2*arg1] */
 
2956
 
 
2957
static PyObject *
 
2958
gl_poly2(PyObject *self, PyObject *args)
 
2959
{
 
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;
 
2973
}
 
2974
 
 
2975
/* void crvn long s float s[3*arg1] */
 
2976
 
 
2977
static PyObject *
 
2978
gl_crvn(PyObject *self, PyObject *args)
 
2979
{
 
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;
 
2993
}
 
2994
 
 
2995
/* void rcrvn long s float s[4*arg1] */
 
2996
 
 
2997
static PyObject *
 
2998
gl_rcrvn(PyObject *self, PyObject *args)
 
2999
{
 
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;
 
3013
}
 
3014
 
 
3015
/* void polf2i long s long s[2*arg1] */
 
3016
 
 
3017
static PyObject *
 
3018
gl_polf2i(PyObject *self, PyObject *args)
 
3019
{
 
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;
 
3033
}
 
3034
 
 
3035
/* void polfi long s long s[3*arg1] */
 
3036
 
 
3037
static PyObject *
 
3038
gl_polfi(PyObject *self, PyObject *args)
 
3039
{
 
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;
 
3053
}
 
3054
 
 
3055
/* void poly2i long s long s[2*arg1] */
 
3056
 
 
3057
static PyObject *
 
3058
gl_poly2i(PyObject *self, PyObject *args)
 
3059
{
 
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;
 
3073
}
 
3074
 
 
3075
/* void polyi long s long s[3*arg1] */
 
3076
 
 
3077
static PyObject *
 
3078
gl_polyi(PyObject *self, PyObject *args)
 
3079
{
 
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;
 
3093
}
 
3094
 
 
3095
/* void polf2s long s short s[2*arg1] */
 
3096
 
 
3097
static PyObject *
 
3098
gl_polf2s(PyObject *self, PyObject *args)
 
3099
{
 
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;
 
3113
}
 
3114
 
 
3115
/* void polfs long s short s[3*arg1] */
 
3116
 
 
3117
static PyObject *
 
3118
gl_polfs(PyObject *self, PyObject *args)
 
3119
{
 
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;
 
3133
}
 
3134
 
 
3135
/* void polys long s short s[3*arg1] */
 
3136
 
 
3137
static PyObject *
 
3138
gl_polys(PyObject *self, PyObject *args)
 
3139
{
 
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;
 
3153
}
 
3154
 
 
3155
/* void poly2s long s short s[2*arg1] */
 
3156
 
 
3157
static PyObject *
 
3158
gl_poly2s(PyObject *self, PyObject *args)
 
3159
{
 
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;
 
3173
}
 
3174
 
 
3175
/* void defcursor short s u_short s[128] */
 
3176
 
 
3177
static PyObject *
 
3178
gl_defcursor(PyObject *self, PyObject *args)
 
3179
{
 
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;
 
3189
}
 
3190
 
 
3191
/* void writepixels short s u_short s[arg1] */
 
3192
 
 
3193
static PyObject *
 
3194
gl_writepixels(PyObject *self, PyObject *args)
 
3195
{
 
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;
 
3208
}
 
3209
 
 
3210
/* void defbasis long s float s[4*4] */
 
3211
 
 
3212
static PyObject *
 
3213
gl_defbasis(PyObject *self, PyObject *args)
 
3214
{
 
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;
 
3224
}
 
3225
 
 
3226
/* void gewrite short s short s[arg1] */
 
3227
 
 
3228
static PyObject *
 
3229
gl_gewrite(PyObject *self, PyObject *args)
 
3230
{
 
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;
 
3243
}
 
3244
 
 
3245
/* void rotate short s char s */
 
3246
 
 
3247
static PyObject *
 
3248
gl_rotate(PyObject *self, PyObject *args)
 
3249
{
 
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;
 
3259
}
 
3260
 
 
3261
/* void rot float s char s */
 
3262
 
 
3263
static PyObject *
 
3264
gl_rot(PyObject *self, PyObject *args)
 
3265
{
 
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;
 
3275
}
 
3276
 
 
3277
/* void circfi long s long s long s */
 
3278
 
 
3279
static PyObject *
 
3280
gl_circfi(PyObject *self, PyObject *args)
 
3281
{
 
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;
 
3294
}
 
3295
 
 
3296
/* void circi long s long s long s */
 
3297
 
 
3298
static PyObject *
 
3299
gl_circi(PyObject *self, PyObject *args)
 
3300
{
 
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;
 
3313
}
 
3314
 
 
3315
/* void cmovi long s long s long s */
 
3316
 
 
3317
static PyObject *
 
3318
gl_cmovi(PyObject *self, PyObject *args)
 
3319
{
 
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;
 
3332
}
 
3333
 
 
3334
/* void drawi long s long s long s */
 
3335
 
 
3336
static PyObject *
 
3337
gl_drawi(PyObject *self, PyObject *args)
 
3338
{
 
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;
 
3351
}
 
3352
 
 
3353
/* void movei long s long s long s */
 
3354
 
 
3355
static PyObject *
 
3356
gl_movei(PyObject *self, PyObject *args)
 
3357
{
 
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;
 
3370
}
 
3371
 
 
3372
/* void pnti long s long s long s */
 
3373
 
 
3374
static PyObject *
 
3375
gl_pnti(PyObject *self, PyObject *args)
 
3376
{
 
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;
 
3389
}
 
3390
 
 
3391
/* void newtag long s long s long s */
 
3392
 
 
3393
static PyObject *
 
3394
gl_newtag(PyObject *self, PyObject *args)
 
3395
{
 
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;
 
3408
}
 
3409
 
 
3410
/* void pdri long s long s long s */
 
3411
 
 
3412
static PyObject *
 
3413
gl_pdri(PyObject *self, PyObject *args)
 
3414
{
 
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;
 
3427
}
 
3428
 
 
3429
/* void pmvi long s long s long s */
 
3430
 
 
3431
static PyObject *
 
3432
gl_pmvi(PyObject *self, PyObject *args)
 
3433
{
 
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;
 
3446
}
 
3447
 
 
3448
/* void rdri long s long s long s */
 
3449
 
 
3450
static PyObject *
 
3451
gl_rdri(PyObject *self, PyObject *args)
 
3452
{
 
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;
 
3465
}
 
3466
 
 
3467
/* void rmvi long s long s long s */
 
3468
 
 
3469
static PyObject *
 
3470
gl_rmvi(PyObject *self, PyObject *args)
 
3471
{
 
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;
 
3484
}
 
3485
 
 
3486
/* void rpdri long s long s long s */
 
3487
 
 
3488
static PyObject *
 
3489
gl_rpdri(PyObject *self, PyObject *args)
 
3490
{
 
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;
 
3503
}
 
3504
 
 
3505
/* void rpmvi long s long s long s */
 
3506
 
 
3507
static PyObject *
 
3508
gl_rpmvi(PyObject *self, PyObject *args)
 
3509
{
 
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;
 
3522
}
 
3523
 
 
3524
/* void xfpti long s long s long s */
 
3525
 
 
3526
static PyObject *
 
3527
gl_xfpti(PyObject *self, PyObject *args)
 
3528
{
 
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;
 
3541
}
 
3542
 
 
3543
/* void circ float s float s float s */
 
3544
 
 
3545
static PyObject *
 
3546
gl_circ(PyObject *self, PyObject *args)
 
3547
{
 
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;
 
3560
}
 
3561
 
 
3562
/* void circf float s float s float s */
 
3563
 
 
3564
static PyObject *
 
3565
gl_circf(PyObject *self, PyObject *args)
 
3566
{
 
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;
 
3579
}
 
3580
 
 
3581
/* void cmov float s float s float s */
 
3582
 
 
3583
static PyObject *
 
3584
gl_cmov(PyObject *self, PyObject *args)
 
3585
{
 
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;
 
3598
}
 
3599
 
 
3600
/* void draw float s float s float s */
 
3601
 
 
3602
static PyObject *
 
3603
gl_draw(PyObject *self, PyObject *args)
 
3604
{
 
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;
 
3617
}
 
3618
 
 
3619
/* void move float s float s float s */
 
3620
 
 
3621
static PyObject *
 
3622
gl_move(PyObject *self, PyObject *args)
 
3623
{
 
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;
 
3636
}
 
3637
 
 
3638
/* void pnt float s float s float s */
 
3639
 
 
3640
static PyObject *
 
3641
gl_pnt(PyObject *self, PyObject *args)
 
3642
{
 
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;
 
3655
}
 
3656
 
 
3657
/* void scale float s float s float s */
 
3658
 
 
3659
static PyObject *
 
3660
gl_scale(PyObject *self, PyObject *args)
 
3661
{
 
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;
 
3674
}
 
3675
 
 
3676
/* void translate float s float s float s */
 
3677
 
 
3678
static PyObject *
 
3679
gl_translate(PyObject *self, PyObject *args)
 
3680
{
 
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;
 
3693
}
 
3694
 
 
3695
/* void pdr float s float s float s */
 
3696
 
 
3697
static PyObject *
 
3698
gl_pdr(PyObject *self, PyObject *args)
 
3699
{
 
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;
 
3712
}
 
3713
 
 
3714
/* void pmv float s float s float s */
 
3715
 
 
3716
static PyObject *
 
3717
gl_pmv(PyObject *self, PyObject *args)
 
3718
{
 
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;
 
3731
}
 
3732
 
 
3733
/* void rdr float s float s float s */
 
3734
 
 
3735
static PyObject *
 
3736
gl_rdr(PyObject *self, PyObject *args)
 
3737
{
 
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;
 
3750
}
 
3751
 
 
3752
/* void rmv float s float s float s */
 
3753
 
 
3754
static PyObject *
 
3755
gl_rmv(PyObject *self, PyObject *args)
 
3756
{
 
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;
 
3769
}
 
3770
 
 
3771
/* void rpdr float s float s float s */
 
3772
 
 
3773
static PyObject *
 
3774
gl_rpdr(PyObject *self, PyObject *args)
 
3775
{
 
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;
 
3788
}
 
3789
 
 
3790
/* void rpmv float s float s float s */
 
3791
 
 
3792
static PyObject *
 
3793
gl_rpmv(PyObject *self, PyObject *args)
 
3794
{
 
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;
 
3807
}
 
3808
 
 
3809
/* void xfpt float s float s float s */
 
3810
 
 
3811
static PyObject *
 
3812
gl_xfpt(PyObject *self, PyObject *args)
 
3813
{
 
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;
 
3826
}
 
3827
 
 
3828
/* void RGBcolor short s short s short s */
 
3829
 
 
3830
static PyObject *
 
3831
gl_RGBcolor(PyObject *self, PyObject *args)
 
3832
{
 
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;
 
3845
}
 
3846
 
 
3847
/* void RGBwritemask short s short s short s */
 
3848
 
 
3849
static PyObject *
 
3850
gl_RGBwritemask(PyObject *self, PyObject *args)
 
3851
{
 
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;
 
3864
}
 
3865
 
 
3866
/* void setcursor short s short s short s */
 
3867
 
 
3868
static PyObject *
 
3869
gl_setcursor(PyObject *self, PyObject *args)
 
3870
{
 
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;
 
3883
}
 
3884
 
 
3885
/* void tie short s short s short s */
 
3886
 
 
3887
static PyObject *
 
3888
gl_tie(PyObject *self, PyObject *args)
 
3889
{
 
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;
 
3902
}
 
3903
 
 
3904
/* void circfs short s short s short s */
 
3905
 
 
3906
static PyObject *
 
3907
gl_circfs(PyObject *self, PyObject *args)
 
3908
{
 
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;
 
3921
}
 
3922
 
 
3923
/* void circs short s short s short s */
 
3924
 
 
3925
static PyObject *
 
3926
gl_circs(PyObject *self, PyObject *args)
 
3927
{
 
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;
 
3940
}
 
3941
 
 
3942
/* void cmovs short s short s short s */
 
3943
 
 
3944
static PyObject *
 
3945
gl_cmovs(PyObject *self, PyObject *args)
 
3946
{
 
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;
 
3959
}
 
3960
 
 
3961
/* void draws short s short s short s */
 
3962
 
 
3963
static PyObject *
 
3964
gl_draws(PyObject *self, PyObject *args)
 
3965
{
 
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;
 
3978
}
 
3979
 
 
3980
/* void moves short s short s short s */
 
3981
 
 
3982
static PyObject *
 
3983
gl_moves(PyObject *self, PyObject *args)
 
3984
{
 
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;
 
3997
}
 
3998
 
 
3999
/* void pdrs short s short s short s */
 
4000
 
 
4001
static PyObject *
 
4002
gl_pdrs(PyObject *self, PyObject *args)
 
4003
{
 
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;
 
4016
}
 
4017
 
 
4018
/* void pmvs short s short s short s */
 
4019
 
 
4020
static PyObject *
 
4021
gl_pmvs(PyObject *self, PyObject *args)
 
4022
{
 
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;
 
4035
}
 
4036
 
 
4037
/* void pnts short s short s short s */
 
4038
 
 
4039
static PyObject *
 
4040
gl_pnts(PyObject *self, PyObject *args)
 
4041
{
 
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;
 
4054
}
 
4055
 
 
4056
/* void rdrs short s short s short s */
 
4057
 
 
4058
static PyObject *
 
4059
gl_rdrs(PyObject *self, PyObject *args)
 
4060
{
 
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;
 
4073
}
 
4074
 
 
4075
/* void rmvs short s short s short s */
 
4076
 
 
4077
static PyObject *
 
4078
gl_rmvs(PyObject *self, PyObject *args)
 
4079
{
 
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;
 
4092
}
 
4093
 
 
4094
/* void rpdrs short s short s short s */
 
4095
 
 
4096
static PyObject *
 
4097
gl_rpdrs(PyObject *self, PyObject *args)
 
4098
{
 
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;
 
4111
}
 
4112
 
 
4113
/* void rpmvs short s short s short s */
 
4114
 
 
4115
static PyObject *
 
4116
gl_rpmvs(PyObject *self, PyObject *args)
 
4117
{
 
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;
 
4130
}
 
4131
 
 
4132
/* void xfpts short s short s short s */
 
4133
 
 
4134
static PyObject *
 
4135
gl_xfpts(PyObject *self, PyObject *args)
 
4136
{
 
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;
 
4149
}
 
4150
 
 
4151
/* void curorigin short s short s short s */
 
4152
 
 
4153
static PyObject *
 
4154
gl_curorigin(PyObject *self, PyObject *args)
 
4155
{
 
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;
 
4168
}
 
4169
 
 
4170
/* void cyclemap short s short s short s */
 
4171
 
 
4172
static PyObject *
 
4173
gl_cyclemap(PyObject *self, PyObject *args)
 
4174
{
 
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;
 
4187
}
 
4188
 
 
4189
/* void patch float s[4*4] float s[4*4] float s[4*4] */
 
4190
 
 
4191
static PyObject *
 
4192
gl_patch(PyObject *self, PyObject *args)
 
4193
{
 
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;
 
4206
}
 
4207
 
 
4208
/* void splf long s float s[3*arg1] u_short s[arg1] */
 
4209
 
 
4210
static PyObject *
 
4211
gl_splf(PyObject *self, PyObject *args)
 
4212
{
 
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;
 
4232
}
 
4233
 
 
4234
/* void splf2 long s float s[2*arg1] u_short s[arg1] */
 
4235
 
 
4236
static PyObject *
 
4237
gl_splf2(PyObject *self, PyObject *args)
 
4238
{
 
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;
 
4258
}
 
4259
 
 
4260
/* void splfi long s long s[3*arg1] u_short s[arg1] */
 
4261
 
 
4262
static PyObject *
 
4263
gl_splfi(PyObject *self, PyObject *args)
 
4264
{
 
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;
 
4284
}
 
4285
 
 
4286
/* void splf2i long s long s[2*arg1] u_short s[arg1] */
 
4287
 
 
4288
static PyObject *
 
4289
gl_splf2i(PyObject *self, PyObject *args)
 
4290
{
 
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;
 
4310
}
 
4311
 
 
4312
/* void splfs long s short s[3*arg1] u_short s[arg1] */
 
4313
 
 
4314
static PyObject *
 
4315
gl_splfs(PyObject *self, PyObject *args)
 
4316
{
 
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;
 
4336
}
 
4337
 
 
4338
/* void splf2s long s short s[2*arg1] u_short s[arg1] */
 
4339
 
 
4340
static PyObject *
 
4341
gl_splf2s(PyObject *self, PyObject *args)
 
4342
{
 
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;
 
4362
}
 
4363
 
 
4364
/* void rpatch float s[4*4] float s[4*4] float s[4*4] float s[4*4] */
 
4365
 
 
4366
static PyObject *
 
4367
gl_rpatch(PyObject *self, PyObject *args)
 
4368
{
 
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;
 
4384
}
 
4385
 
 
4386
/* void ortho2 float s float s float s float s */
 
4387
 
 
4388
static PyObject *
 
4389
gl_ortho2(PyObject *self, PyObject *args)
 
4390
{
 
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;
 
4406
}
 
4407
 
 
4408
/* void rect float s float s float s float s */
 
4409
 
 
4410
static PyObject *
 
4411
gl_rect(PyObject *self, PyObject *args)
 
4412
{
 
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;
 
4428
}
 
4429
 
 
4430
/* void rectf float s float s float s float s */
 
4431
 
 
4432
static PyObject *
 
4433
gl_rectf(PyObject *self, PyObject *args)
 
4434
{
 
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;
 
4450
}
 
4451
 
 
4452
/* void xfpt4 float s float s float s float s */
 
4453
 
 
4454
static PyObject *
 
4455
gl_xfpt4(PyObject *self, PyObject *args)
 
4456
{
 
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;
 
4472
}
 
4473
 
 
4474
/* void textport short s short s short s short s */
 
4475
 
 
4476
static PyObject *
 
4477
gl_textport(PyObject *self, PyObject *args)
 
4478
{
 
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;
 
4494
}
 
4495
 
 
4496
/* void mapcolor short s short s short s short s */
 
4497
 
 
4498
static PyObject *
 
4499
gl_mapcolor(PyObject *self, PyObject *args)
 
4500
{
 
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;
 
4516
}
 
4517
 
 
4518
/* void scrmask short s short s short s short s */
 
4519
 
 
4520
static PyObject *
 
4521
gl_scrmask(PyObject *self, PyObject *args)
 
4522
{
 
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;
 
4538
}
 
4539
 
 
4540
/* void setvaluator short s short s short s short s */
 
4541
 
 
4542
static PyObject *
 
4543
gl_setvaluator(PyObject *self, PyObject *args)
 
4544
{
 
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;
 
4560
}
 
4561
 
 
4562
/* void viewport short s short s short s short s */
 
4563
 
 
4564
static PyObject *
 
4565
gl_viewport(PyObject *self, PyObject *args)
 
4566
{
 
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;
 
4582
}
 
4583
 
 
4584
/* void shaderange short s short s short s short s */
 
4585
 
 
4586
static PyObject *
 
4587
gl_shaderange(PyObject *self, PyObject *args)
 
4588
{
 
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;
 
4604
}
 
4605
 
 
4606
/* void xfpt4s short s short s short s short s */
 
4607
 
 
4608
static PyObject *
 
4609
gl_xfpt4s(PyObject *self, PyObject *args)
 
4610
{
 
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;
 
4626
}
 
4627
 
 
4628
/* void rectfi long s long s long s long s */
 
4629
 
 
4630
static PyObject *
 
4631
gl_rectfi(PyObject *self, PyObject *args)
 
4632
{
 
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;
 
4648
}
 
4649
 
 
4650
/* void recti long s long s long s long s */
 
4651
 
 
4652
static PyObject *
 
4653
gl_recti(PyObject *self, PyObject *args)
 
4654
{
 
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;
 
4670
}
 
4671
 
 
4672
/* void xfpt4i long s long s long s long s */
 
4673
 
 
4674
static PyObject *
 
4675
gl_xfpt4i(PyObject *self, PyObject *args)
 
4676
{
 
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;
 
4692
}
 
4693
 
 
4694
/* void prefposition long s long s long s long s */
 
4695
 
 
4696
static PyObject *
 
4697
gl_prefposition(PyObject *self, PyObject *args)
 
4698
{
 
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;
 
4714
}
 
4715
 
 
4716
/* void arc float s float s float s short s short s */
 
4717
 
 
4718
static PyObject *
 
4719
gl_arc(PyObject *self, PyObject *args)
 
4720
{
 
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;
 
4739
}
 
4740
 
 
4741
/* void arcf float s float s float s short s short s */
 
4742
 
 
4743
static PyObject *
 
4744
gl_arcf(PyObject *self, PyObject *args)
 
4745
{
 
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;
 
4764
}
 
4765
 
 
4766
/* void arcfi long s long s long s short s short s */
 
4767
 
 
4768
static PyObject *
 
4769
gl_arcfi(PyObject *self, PyObject *args)
 
4770
{
 
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;
 
4789
}
 
4790
 
 
4791
/* void arci long s long s long s short s short s */
 
4792
 
 
4793
static PyObject *
 
4794
gl_arci(PyObject *self, PyObject *args)
 
4795
{
 
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;
 
4814
}
 
4815
 
 
4816
/* void bbox2 short s short s float s float s float s float s */
 
4817
 
 
4818
static PyObject *
 
4819
gl_bbox2(PyObject *self, PyObject *args)
 
4820
{
 
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;
 
4842
}
 
4843
 
 
4844
/* void bbox2i short s short s long s long s long s long s */
 
4845
 
 
4846
static PyObject *
 
4847
gl_bbox2i(PyObject *self, PyObject *args)
 
4848
{
 
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;
 
4870
}
 
4871
 
 
4872
/* void bbox2s short s short s short s short s short s short s */
 
4873
 
 
4874
static PyObject *
 
4875
gl_bbox2s(PyObject *self, PyObject *args)
 
4876
{
 
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;
 
4898
}
 
4899
 
 
4900
/* void blink short s short s short s short s short s */
 
4901
 
 
4902
static PyObject *
 
4903
gl_blink(PyObject *self, PyObject *args)
 
4904
{
 
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;
 
4923
}
 
4924
 
 
4925
/* void ortho float s float s float s float s float s float s */
 
4926
 
 
4927
static PyObject *
 
4928
gl_ortho(PyObject *self, PyObject *args)
 
4929
{
 
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;
 
4951
}
 
4952
 
 
4953
/* void window float s float s float s float s float s float s */
 
4954
 
 
4955
static PyObject *
 
4956
gl_window(PyObject *self, PyObject *args)
 
4957
{
 
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;
 
4979
}
 
4980
 
 
4981
/* void lookat float s float s float s float s float s float s short s */
 
4982
 
 
4983
static PyObject *
 
4984
gl_lookat(PyObject *self, PyObject *args)
 
4985
{
 
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;
 
5010
}
 
5011
 
 
5012
/* void perspective short s float s float s float s */
 
5013
 
 
5014
static PyObject *
 
5015
gl_perspective(PyObject *self, PyObject *args)
 
5016
{
 
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;
 
5032
}
 
5033
 
 
5034
/* void polarview float s short s short s short s */
 
5035
 
 
5036
static PyObject *
 
5037
gl_polarview(PyObject *self, PyObject *args)
 
5038
{
 
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;
 
5054
}
 
5055
 
 
5056
/* void arcfs short s short s short s short s short s */
 
5057
 
 
5058
static PyObject *
 
5059
gl_arcfs(PyObject *self, PyObject *args)
 
5060
{
 
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;
 
5079
}
 
5080
 
 
5081
/* void arcs short s short s short s short s short s */
 
5082
 
 
5083
static PyObject *
 
5084
gl_arcs(PyObject *self, PyObject *args)
 
5085
{
 
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;
 
5104
}
 
5105
 
 
5106
/* void rectcopy short s short s short s short s short s short s */
 
5107
 
 
5108
static PyObject *
 
5109
gl_rectcopy(PyObject *self, PyObject *args)
 
5110
{
 
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;
 
5132
}
 
5133
 
 
5134
/* void RGBcursor short s short s short s short s short s short s short s */
 
5135
 
 
5136
static PyObject *
 
5137
gl_RGBcursor(PyObject *self, PyObject *args)
 
5138
{
 
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;
 
5163
}
 
5164
 
 
5165
/* long getbutton short s */
 
5166
 
 
5167
static PyObject *
 
5168
gl_getbutton(PyObject *self, PyObject *args)
 
5169
{
 
5170
        long retval;
 
5171
        short arg1 ;
 
5172
        if (!getishortarg(args, 1, 0, &arg1))
 
5173
                return NULL;
 
5174
        retval = getbutton( arg1 );
 
5175
        return mknewlongobject(retval);
 
5176
}
 
5177
 
 
5178
/* long getcmmode */
 
5179
 
 
5180
static PyObject *
 
5181
gl_getcmmode(PyObject *self, PyObject *args)
 
5182
{
 
5183
        long retval;
 
5184
        retval = getcmmode( );
 
5185
        return mknewlongobject(retval);
 
5186
}
 
5187
 
 
5188
/* long getlsbackup */
 
5189
 
 
5190
static PyObject *
 
5191
gl_getlsbackup(PyObject *self, PyObject *args)
 
5192
{
 
5193
        long retval;
 
5194
        retval = getlsbackup( );
 
5195
        return mknewlongobject(retval);
 
5196
}
 
5197
 
 
5198
/* long getresetls */
 
5199
 
 
5200
static PyObject *
 
5201
gl_getresetls(PyObject *self, PyObject *args)
 
5202
{
 
5203
        long retval;
 
5204
        retval = getresetls( );
 
5205
        return mknewlongobject(retval);
 
5206
}
 
5207
 
 
5208
/* long getdcm */
 
5209
 
 
5210
static PyObject *
 
5211
gl_getdcm(PyObject *self, PyObject *args)
 
5212
{
 
5213
        long retval;
 
5214
        retval = getdcm( );
 
5215
        return mknewlongobject(retval);
 
5216
}
 
5217
 
 
5218
/* long getzbuffer */
 
5219
 
 
5220
static PyObject *
 
5221
gl_getzbuffer(PyObject *self, PyObject *args)
 
5222
{
 
5223
        long retval;
 
5224
        retval = getzbuffer( );
 
5225
        return mknewlongobject(retval);
 
5226
}
 
5227
 
 
5228
/* long ismex */
 
5229
 
 
5230
static PyObject *
 
5231
gl_ismex(PyObject *self, PyObject *args)
 
5232
{
 
5233
        long retval;
 
5234
        retval = ismex( );
 
5235
        return mknewlongobject(retval);
 
5236
}
 
5237
 
 
5238
/* long isobj long s */
 
5239
 
 
5240
static PyObject *
 
5241
gl_isobj(PyObject *self, PyObject *args)
 
5242
{
 
5243
        long retval;
 
5244
        long arg1 ;
 
5245
        if (!getilongarg(args, 1, 0, &arg1))
 
5246
                return NULL;
 
5247
        retval = isobj( arg1 );
 
5248
        return mknewlongobject(retval);
 
5249
}
 
5250
 
 
5251
/* long isqueued short s */
 
5252
 
 
5253
static PyObject *
 
5254
gl_isqueued(PyObject *self, PyObject *args)
 
5255
{
 
5256
        long retval;
 
5257
        short arg1 ;
 
5258
        if (!getishortarg(args, 1, 0, &arg1))
 
5259
                return NULL;
 
5260
        retval = isqueued( arg1 );
 
5261
        return mknewlongobject(retval);
 
5262
}
 
5263
 
 
5264
/* long istag long s */
 
5265
 
 
5266
static PyObject *
 
5267
gl_istag(PyObject *self, PyObject *args)
 
5268
{
 
5269
        long retval;
 
5270
        long arg1 ;
 
5271
        if (!getilongarg(args, 1, 0, &arg1))
 
5272
                return NULL;
 
5273
        retval = istag( arg1 );
 
5274
        return mknewlongobject(retval);
 
5275
}
 
5276
 
 
5277
/* long genobj */
 
5278
 
 
5279
static PyObject *
 
5280
gl_genobj(PyObject *self, PyObject *args)
 
5281
{
 
5282
        long retval;
 
5283
        retval = genobj( );
 
5284
        return mknewlongobject(retval);
 
5285
}
 
5286
 
 
5287
/* long gentag */
 
5288
 
 
5289
static PyObject *
 
5290
gl_gentag(PyObject *self, PyObject *args)
 
5291
{
 
5292
        long retval;
 
5293
        retval = gentag( );
 
5294
        return mknewlongobject(retval);
 
5295
}
 
5296
 
 
5297
/* long getbuffer */
 
5298
 
 
5299
static PyObject *
 
5300
gl_getbuffer(PyObject *self, PyObject *args)
 
5301
{
 
5302
        long retval;
 
5303
        retval = getbuffer( );
 
5304
        return mknewlongobject(retval);
 
5305
}
 
5306
 
 
5307
/* long getcolor */
 
5308
 
 
5309
static PyObject *
 
5310
gl_getcolor(PyObject *self, PyObject *args)
 
5311
{
 
5312
        long retval;
 
5313
        retval = getcolor( );
 
5314
        return mknewlongobject(retval);
 
5315
}
 
5316
 
 
5317
/* long getdisplaymode */
 
5318
 
 
5319
static PyObject *
 
5320
gl_getdisplaymode(PyObject *self, PyObject *args)
 
5321
{
 
5322
        long retval;
 
5323
        retval = getdisplaymode( );
 
5324
        return mknewlongobject(retval);
 
5325
}
 
5326
 
 
5327
/* long getfont */
 
5328
 
 
5329
static PyObject *
 
5330
gl_getfont(PyObject *self, PyObject *args)
 
5331
{
 
5332
        long retval;
 
5333
        retval = getfont( );
 
5334
        return mknewlongobject(retval);
 
5335
}
 
5336
 
 
5337
/* long getheight */
 
5338
 
 
5339
static PyObject *
 
5340
gl_getheight(PyObject *self, PyObject *args)
 
5341
{
 
5342
        long retval;
 
5343
        retval = getheight( );
 
5344
        return mknewlongobject(retval);
 
5345
}
 
5346
 
 
5347
/* long gethitcode */
 
5348
 
 
5349
static PyObject *
 
5350
gl_gethitcode(PyObject *self, PyObject *args)
 
5351
{
 
5352
        long retval;
 
5353
        retval = gethitcode( );
 
5354
        return mknewlongobject(retval);
 
5355
}
 
5356
 
 
5357
/* long getlstyle */
 
5358
 
 
5359
static PyObject *
 
5360
gl_getlstyle(PyObject *self, PyObject *args)
 
5361
{
 
5362
        long retval;
 
5363
        retval = getlstyle( );
 
5364
        return mknewlongobject(retval);
 
5365
}
 
5366
 
 
5367
/* long getlwidth */
 
5368
 
 
5369
static PyObject *
 
5370
gl_getlwidth(PyObject *self, PyObject *args)
 
5371
{
 
5372
        long retval;
 
5373
        retval = getlwidth( );
 
5374
        return mknewlongobject(retval);
 
5375
}
 
5376
 
 
5377
/* long getmap */
 
5378
 
 
5379
static PyObject *
 
5380
gl_getmap(PyObject *self, PyObject *args)
 
5381
{
 
5382
        long retval;
 
5383
        retval = getmap( );
 
5384
        return mknewlongobject(retval);
 
5385
}
 
5386
 
 
5387
/* long getplanes */
 
5388
 
 
5389
static PyObject *
 
5390
gl_getplanes(PyObject *self, PyObject *args)
 
5391
{
 
5392
        long retval;
 
5393
        retval = getplanes( );
 
5394
        return mknewlongobject(retval);
 
5395
}
 
5396
 
 
5397
/* long getwritemask */
 
5398
 
 
5399
static PyObject *
 
5400
gl_getwritemask(PyObject *self, PyObject *args)
 
5401
{
 
5402
        long retval;
 
5403
        retval = getwritemask( );
 
5404
        return mknewlongobject(retval);
 
5405
}
 
5406
 
 
5407
/* long qtest */
 
5408
 
 
5409
static PyObject *
 
5410
gl_qtest(PyObject *self, PyObject *args)
 
5411
{
 
5412
        long retval;
 
5413
        retval = qtest( );
 
5414
        return mknewlongobject(retval);
 
5415
}
 
5416
 
 
5417
/* long getlsrepeat */
 
5418
 
 
5419
static PyObject *
 
5420
gl_getlsrepeat(PyObject *self, PyObject *args)
 
5421
{
 
5422
        long retval;
 
5423
        retval = getlsrepeat( );
 
5424
        return mknewlongobject(retval);
 
5425
}
 
5426
 
 
5427
/* long getmonitor */
 
5428
 
 
5429
static PyObject *
 
5430
gl_getmonitor(PyObject *self, PyObject *args)
 
5431
{
 
5432
        long retval;
 
5433
        retval = getmonitor( );
 
5434
        return mknewlongobject(retval);
 
5435
}
 
5436
 
 
5437
/* long getopenobj */
 
5438
 
 
5439
static PyObject *
 
5440
gl_getopenobj(PyObject *self, PyObject *args)
 
5441
{
 
5442
        long retval;
 
5443
        retval = getopenobj( );
 
5444
        return mknewlongobject(retval);
 
5445
}
 
5446
 
 
5447
/* long getpattern */
 
5448
 
 
5449
static PyObject *
 
5450
gl_getpattern(PyObject *self, PyObject *args)
 
5451
{
 
5452
        long retval;
 
5453
        retval = getpattern( );
 
5454
        return mknewlongobject(retval);
 
5455
}
 
5456
 
 
5457
/* long winget */
 
5458
 
 
5459
static PyObject *
 
5460
gl_winget(PyObject *self, PyObject *args)
 
5461
{
 
5462
        long retval;
 
5463
        retval = winget( );
 
5464
        return mknewlongobject(retval);
 
5465
}
 
5466
 
 
5467
/* long winattach */
 
5468
 
 
5469
static PyObject *
 
5470
gl_winattach(PyObject *self, PyObject *args)
 
5471
{
 
5472
        long retval;
 
5473
        retval = winattach( );
 
5474
        return mknewlongobject(retval);
 
5475
}
 
5476
 
 
5477
/* long getothermonitor */
 
5478
 
 
5479
static PyObject *
 
5480
gl_getothermonitor(PyObject *self, PyObject *args)
 
5481
{
 
5482
        long retval;
 
5483
        retval = getothermonitor( );
 
5484
        return mknewlongobject(retval);
 
5485
}
 
5486
 
 
5487
/* long newpup */
 
5488
 
 
5489
static PyObject *
 
5490
gl_newpup(PyObject *self, PyObject *args)
 
5491
{
 
5492
        long retval;
 
5493
        retval = newpup( );
 
5494
        return mknewlongobject(retval);
 
5495
}
 
5496
 
 
5497
/* long getvaluator short s */
 
5498
 
 
5499
static PyObject *
 
5500
gl_getvaluator(PyObject *self, PyObject *args)
 
5501
{
 
5502
        long retval;
 
5503
        short arg1 ;
 
5504
        if (!getishortarg(args, 1, 0, &arg1))
 
5505
                return NULL;
 
5506
        retval = getvaluator( arg1 );
 
5507
        return mknewlongobject(retval);
 
5508
}
 
5509
 
 
5510
/* void winset long s */
 
5511
 
 
5512
static PyObject *
 
5513
gl_winset(PyObject *self, PyObject *args)
 
5514
{
 
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;
 
5521
}
 
5522
 
 
5523
/* long dopup long s */
 
5524
 
 
5525
static PyObject *
 
5526
gl_dopup(PyObject *self, PyObject *args)
 
5527
{
 
5528
        long retval;
 
5529
        long arg1 ;
 
5530
        if (!getilongarg(args, 1, 0, &arg1))
 
5531
                return NULL;
 
5532
        retval = dopup( arg1 );
 
5533
        return mknewlongobject(retval);
 
5534
}
 
5535
 
 
5536
/* void getdepth short r short r */
 
5537
 
 
5538
static PyObject *
 
5539
gl_getdepth(PyObject *self, PyObject *args)
 
5540
{
 
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
        }
 
5550
}
 
5551
 
 
5552
/* void getcpos short r short r */
 
5553
 
 
5554
static PyObject *
 
5555
gl_getcpos(PyObject *self, PyObject *args)
 
5556
{
 
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
        }
 
5566
}
 
5567
 
 
5568
/* void getsize long r long r */
 
5569
 
 
5570
static PyObject *
 
5571
gl_getsize(PyObject *self, PyObject *args)
 
5572
{
 
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
        }
 
5582
}
 
5583
 
 
5584
/* void getorigin long r long r */
 
5585
 
 
5586
static PyObject *
 
5587
gl_getorigin(PyObject *self, PyObject *args)
 
5588
{
 
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
        }
 
5598
}
 
5599
 
 
5600
/* void getviewport short r short r short r short r */
 
5601
 
 
5602
static PyObject *
 
5603
gl_getviewport(PyObject *self, PyObject *args)
 
5604
{
 
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
        }
 
5618
}
 
5619
 
 
5620
/* void gettp short r short r short r short r */
 
5621
 
 
5622
static PyObject *
 
5623
gl_gettp(PyObject *self, PyObject *args)
 
5624
{
 
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
        }
 
5638
}
 
5639
 
 
5640
/* void getgpos float r float r float r float r */
 
5641
 
 
5642
static PyObject *
 
5643
gl_getgpos(PyObject *self, PyObject *args)
 
5644
{
 
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
        }
 
5658
}
 
5659
 
 
5660
/* void winposition long s long s long s long s */
 
5661
 
 
5662
static PyObject *
 
5663
gl_winposition(PyObject *self, PyObject *args)
 
5664
{
 
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;
 
5680
}
 
5681
 
 
5682
/* void gRGBcolor short r short r short r */
 
5683
 
 
5684
static PyObject *
 
5685
gl_gRGBcolor(PyObject *self, PyObject *args)
 
5686
{
 
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
        }
 
5698
}
 
5699
 
 
5700
/* void gRGBmask short r short r short r */
 
5701
 
 
5702
static PyObject *
 
5703
gl_gRGBmask(PyObject *self, PyObject *args)
 
5704
{
 
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
        }
 
5716
}
 
5717
 
 
5718
/* void getscrmask short r short r short r short r */
 
5719
 
 
5720
static PyObject *
 
5721
gl_getscrmask(PyObject *self, PyObject *args)
 
5722
{
 
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
        }
 
5736
}
 
5737
 
 
5738
/* void getmcolor short s short r short r short r */
 
5739
 
 
5740
static PyObject *
 
5741
gl_getmcolor(PyObject *self, PyObject *args)
 
5742
{
 
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
        }
 
5757
}
 
5758
 
 
5759
/* void mapw long s short s short s float r float r float r float r float r float r */
 
5760
 
 
5761
static PyObject *
 
5762
gl_mapw(PyObject *self, PyObject *args)
 
5763
{
 
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
        }
 
5790
}
 
5791
 
 
5792
/* void mapw2 long s short s short s float r float r */
 
5793
 
 
5794
static PyObject *
 
5795
gl_mapw2(PyObject *self, PyObject *args)
 
5796
{
 
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
        }
 
5815
}
 
5816
 
 
5817
/* void getcursor short r u_short r u_short r long r */
 
5818
 
 
5819
static PyObject *
 
5820
gl_getcursor(PyObject *self, PyObject *args)
 
5821
{
 
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
        }
 
5835
}
 
5836
 
 
5837
/* void cmode */
 
5838
 
 
5839
static PyObject *
 
5840
gl_cmode(PyObject *self, PyObject *args)
 
5841
{
 
5842
        cmode( );
 
5843
        Py_INCREF(Py_None);
 
5844
        return Py_None;
 
5845
}
 
5846
 
 
5847
/* void concave long s */
 
5848
 
 
5849
static PyObject *
 
5850
gl_concave(PyObject *self, PyObject *args)
 
5851
{
 
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;
 
5858
}
 
5859
 
 
5860
/* void curstype long s */
 
5861
 
 
5862
static PyObject *
 
5863
gl_curstype(PyObject *self, PyObject *args)
 
5864
{
 
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;
 
5871
}
 
5872
 
 
5873
/* void drawmode long s */
 
5874
 
 
5875
static PyObject *
 
5876
gl_drawmode(PyObject *self, PyObject *args)
 
5877
{
 
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;
 
5884
}
 
5885
 
 
5886
/* void gammaramp short s[256] short s[256] short s[256] */
 
5887
 
 
5888
static PyObject *
 
5889
gl_gammaramp(PyObject *self, PyObject *args)
 
5890
{
 
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;
 
5903
}
 
5904
 
 
5905
/* long getbackface */
 
5906
 
 
5907
static PyObject *
 
5908
gl_getbackface(PyObject *self, PyObject *args)
 
5909
{
 
5910
        long retval;
 
5911
        retval = getbackface( );
 
5912
        return mknewlongobject(retval);
 
5913
}
 
5914
 
 
5915
/* long getdescender */
 
5916
 
 
5917
static PyObject *
 
5918
gl_getdescender(PyObject *self, PyObject *args)
 
5919
{
 
5920
        long retval;
 
5921
        retval = getdescender( );
 
5922
        return mknewlongobject(retval);
 
5923
}
 
5924
 
 
5925
/* long getdrawmode */
 
5926
 
 
5927
static PyObject *
 
5928
gl_getdrawmode(PyObject *self, PyObject *args)
 
5929
{
 
5930
        long retval;
 
5931
        retval = getdrawmode( );
 
5932
        return mknewlongobject(retval);
 
5933
}
 
5934
 
 
5935
/* long getmmode */
 
5936
 
 
5937
static PyObject *
 
5938
gl_getmmode(PyObject *self, PyObject *args)
 
5939
{
 
5940
        long retval;
 
5941
        retval = getmmode( );
 
5942
        return mknewlongobject(retval);
 
5943
}
 
5944
 
 
5945
/* long getsm */
 
5946
 
 
5947
static PyObject *
 
5948
gl_getsm(PyObject *self, PyObject *args)
 
5949
{
 
5950
        long retval;
 
5951
        retval = getsm( );
 
5952
        return mknewlongobject(retval);
 
5953
}
 
5954
 
 
5955
/* long getvideo long s */
 
5956
 
 
5957
static PyObject *
 
5958
gl_getvideo(PyObject *self, PyObject *args)
 
5959
{
 
5960
        long retval;
 
5961
        long arg1 ;
 
5962
        if (!getilongarg(args, 1, 0, &arg1))
 
5963
                return NULL;
 
5964
        retval = getvideo( arg1 );
 
5965
        return mknewlongobject(retval);
 
5966
}
 
5967
 
 
5968
/* void imakebackground */
 
5969
 
 
5970
static PyObject *
 
5971
gl_imakebackground(PyObject *self, PyObject *args)
 
5972
{
 
5973
        imakebackground( );
 
5974
        Py_INCREF(Py_None);
 
5975
        return Py_None;
 
5976
}
 
5977
 
 
5978
/* void lmbind short s short s */
 
5979
 
 
5980
static PyObject *
 
5981
gl_lmbind(PyObject *self, PyObject *args)
 
5982
{
 
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;
 
5992
}
 
5993
 
 
5994
/* void lmdef long s long s long s float s[arg3] */
 
5995
 
 
5996
static PyObject *
 
5997
gl_lmdef(PyObject *self, PyObject *args)
 
5998
{
 
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;
 
6017
}
 
6018
 
 
6019
/* void mmode long s */
 
6020
 
 
6021
static PyObject *
 
6022
gl_mmode(PyObject *self, PyObject *args)
 
6023
{
 
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;
 
6030
}
 
6031
 
 
6032
/* void normal float s[3] */
 
6033
 
 
6034
static PyObject *
 
6035
gl_normal(PyObject *self, PyObject *args)
 
6036
{
 
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;
 
6043
}
 
6044
 
 
6045
/* void overlay long s */
 
6046
 
 
6047
static PyObject *
 
6048
gl_overlay(PyObject *self, PyObject *args)
 
6049
{
 
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;
 
6056
}
 
6057
 
 
6058
/* void RGBrange short s short s short s short s short s short s short s short s */
 
6059
 
 
6060
static PyObject *
 
6061
gl_RGBrange(PyObject *self, PyObject *args)
 
6062
{
 
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;
 
6090
}
 
6091
 
 
6092
/* void setvideo long s long s */
 
6093
 
 
6094
static PyObject *
 
6095
gl_setvideo(PyObject *self, PyObject *args)
 
6096
{
 
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;
 
6106
}
 
6107
 
 
6108
/* void shademodel long s */
 
6109
 
 
6110
static PyObject *
 
6111
gl_shademodel(PyObject *self, PyObject *args)
 
6112
{
 
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;
 
6119
}
 
6120
 
 
6121
/* void underlay long s */
 
6122
 
 
6123
static PyObject *
 
6124
gl_underlay(PyObject *self, PyObject *args)
 
6125
{
 
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;
 
6132
}
 
6133
 
 
6134
/* void bgnclosedline */
 
6135
 
 
6136
static PyObject *
 
6137
gl_bgnclosedline(PyObject *self, PyObject *args)
 
6138
{
 
6139
        bgnclosedline( );
 
6140
        Py_INCREF(Py_None);
 
6141
        return Py_None;
 
6142
}
 
6143
 
 
6144
/* void bgnline */
 
6145
 
 
6146
static PyObject *
 
6147
gl_bgnline(PyObject *self, PyObject *args)
 
6148
{
 
6149
        bgnline( );
 
6150
        Py_INCREF(Py_None);
 
6151
        return Py_None;
 
6152
}
 
6153
 
 
6154
/* void bgnpoint */
 
6155
 
 
6156
static PyObject *
 
6157
gl_bgnpoint(PyObject *self, PyObject *args)
 
6158
{
 
6159
        bgnpoint( );
 
6160
        Py_INCREF(Py_None);
 
6161
        return Py_None;
 
6162
}
 
6163
 
 
6164
/* void bgnpolygon */
 
6165
 
 
6166
static PyObject *
 
6167
gl_bgnpolygon(PyObject *self, PyObject *args)
 
6168
{
 
6169
        bgnpolygon( );
 
6170
        Py_INCREF(Py_None);
 
6171
        return Py_None;
 
6172
}
 
6173
 
 
6174
/* void bgnsurface */
 
6175
 
 
6176
static PyObject *
 
6177
gl_bgnsurface(PyObject *self, PyObject *args)
 
6178
{
 
6179
        bgnsurface( );
 
6180
        Py_INCREF(Py_None);
 
6181
        return Py_None;
 
6182
}
 
6183
 
 
6184
/* void bgntmesh */
 
6185
 
 
6186
static PyObject *
 
6187
gl_bgntmesh(PyObject *self, PyObject *args)
 
6188
{
 
6189
        bgntmesh( );
 
6190
        Py_INCREF(Py_None);
 
6191
        return Py_None;
 
6192
}
 
6193
 
 
6194
/* void bgntrim */
 
6195
 
 
6196
static PyObject *
 
6197
gl_bgntrim(PyObject *self, PyObject *args)
 
6198
{
 
6199
        bgntrim( );
 
6200
        Py_INCREF(Py_None);
 
6201
        return Py_None;
 
6202
}
 
6203
 
 
6204
/* void endclosedline */
 
6205
 
 
6206
static PyObject *
 
6207
gl_endclosedline(PyObject *self, PyObject *args)
 
6208
{
 
6209
        endclosedline( );
 
6210
        Py_INCREF(Py_None);
 
6211
        return Py_None;
 
6212
}
 
6213
 
 
6214
/* void endline */
 
6215
 
 
6216
static PyObject *
 
6217
gl_endline(PyObject *self, PyObject *args)
 
6218
{
 
6219
        endline( );
 
6220
        Py_INCREF(Py_None);
 
6221
        return Py_None;
 
6222
}
 
6223
 
 
6224
/* void endpoint */
 
6225
 
 
6226
static PyObject *
 
6227
gl_endpoint(PyObject *self, PyObject *args)
 
6228
{
 
6229
        endpoint( );
 
6230
        Py_INCREF(Py_None);
 
6231
        return Py_None;
 
6232
}
 
6233
 
 
6234
/* void endpolygon */
 
6235
 
 
6236
static PyObject *
 
6237
gl_endpolygon(PyObject *self, PyObject *args)
 
6238
{
 
6239
        endpolygon( );
 
6240
        Py_INCREF(Py_None);
 
6241
        return Py_None;
 
6242
}
 
6243
 
 
6244
/* void endsurface */
 
6245
 
 
6246
static PyObject *
 
6247
gl_endsurface(PyObject *self, PyObject *args)
 
6248
{
 
6249
        endsurface( );
 
6250
        Py_INCREF(Py_None);
 
6251
        return Py_None;
 
6252
}
 
6253
 
 
6254
/* void endtmesh */
 
6255
 
 
6256
static PyObject *
 
6257
gl_endtmesh(PyObject *self, PyObject *args)
 
6258
{
 
6259
        endtmesh( );
 
6260
        Py_INCREF(Py_None);
 
6261
        return Py_None;
 
6262
}
 
6263
 
 
6264
/* void endtrim */
 
6265
 
 
6266
static PyObject *
 
6267
gl_endtrim(PyObject *self, PyObject *args)
 
6268
{
 
6269
        endtrim( );
 
6270
        Py_INCREF(Py_None);
 
6271
        return Py_None;
 
6272
}
 
6273
 
 
6274
/* void blendfunction long s long s */
 
6275
 
 
6276
static PyObject *
 
6277
gl_blendfunction(PyObject *self, PyObject *args)
 
6278
{
 
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;
 
6288
}
 
6289
 
 
6290
/* void c3f float s[3] */
 
6291
 
 
6292
static PyObject *
 
6293
gl_c3f(PyObject *self, PyObject *args)
 
6294
{
 
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;
 
6301
}
 
6302
 
 
6303
/* void c3i long s[3] */
 
6304
 
 
6305
static PyObject *
 
6306
gl_c3i(PyObject *self, PyObject *args)
 
6307
{
 
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;
 
6314
}
 
6315
 
 
6316
/* void c3s short s[3] */
 
6317
 
 
6318
static PyObject *
 
6319
gl_c3s(PyObject *self, PyObject *args)
 
6320
{
 
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;
 
6327
}
 
6328
 
 
6329
/* void c4f float s[4] */
 
6330
 
 
6331
static PyObject *
 
6332
gl_c4f(PyObject *self, PyObject *args)
 
6333
{
 
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;
 
6340
}
 
6341
 
 
6342
/* void c4i long s[4] */
 
6343
 
 
6344
static PyObject *
 
6345
gl_c4i(PyObject *self, PyObject *args)
 
6346
{
 
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;
 
6353
}
 
6354
 
 
6355
/* void c4s short s[4] */
 
6356
 
 
6357
static PyObject *
 
6358
gl_c4s(PyObject *self, PyObject *args)
 
6359
{
 
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;
 
6366
}
 
6367
 
 
6368
/* void colorf float s */
 
6369
 
 
6370
static PyObject *
 
6371
gl_colorf(PyObject *self, PyObject *args)
 
6372
{
 
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;
 
6379
}
 
6380
 
 
6381
/* void cpack long s */
 
6382
 
 
6383
static PyObject *
 
6384
gl_cpack(PyObject *self, PyObject *args)
 
6385
{
 
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;
 
6392
}
 
6393
 
 
6394
/* void czclear long s long s */
 
6395
 
 
6396
static PyObject *
 
6397
gl_czclear(PyObject *self, PyObject *args)
 
6398
{
 
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;
 
6408
}
 
6409
 
 
6410
/* void dglclose long s */
 
6411
 
 
6412
static PyObject *
 
6413
gl_dglclose(PyObject *self, PyObject *args)
 
6414
{
 
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;
 
6421
}
 
6422
 
 
6423
/* long dglopen char *s long s */
 
6424
 
 
6425
static PyObject *
 
6426
gl_dglopen(PyObject *self, PyObject *args)
 
6427
{
 
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);
 
6437
}
 
6438
 
 
6439
/* long getgdesc long s */
 
6440
 
 
6441
static PyObject *
 
6442
gl_getgdesc(PyObject *self, PyObject *args)
 
6443
{
 
6444
        long retval;
 
6445
        long arg1 ;
 
6446
        if (!getilongarg(args, 1, 0, &arg1))
 
6447
                return NULL;
 
6448
        retval = getgdesc( arg1 );
 
6449
        return mknewlongobject(retval);
 
6450
}
 
6451
 
 
6452
/* void getnurbsproperty long s float r */
 
6453
 
 
6454
static PyObject *
 
6455
gl_getnurbsproperty(PyObject *self, PyObject *args)
 
6456
{
 
6457
        long arg1 ;
 
6458
        float arg2 ;
 
6459
        if (!getilongarg(args, 1, 0, &arg1))
 
6460
                return NULL;
 
6461
        getnurbsproperty( arg1 , & arg2 );
 
6462
        return mknewfloatobject(arg2);
 
6463
}
 
6464
 
 
6465
/* void glcompat long s long s */
 
6466
 
 
6467
static PyObject *
 
6468
gl_glcompat(PyObject *self, PyObject *args)
 
6469
{
 
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;
 
6479
}
 
6480
 
 
6481
/* void iconsize long s long s */
 
6482
 
 
6483
static PyObject *
 
6484
gl_iconsize(PyObject *self, PyObject *args)
 
6485
{
 
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;
 
6495
}
 
6496
 
 
6497
/* void icontitle char *s */
 
6498
 
 
6499
static PyObject *
 
6500
gl_icontitle(PyObject *self, PyObject *args)
 
6501
{
 
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;
 
6508
}
 
6509
 
 
6510
/* void lRGBrange short s short s short s short s short s short s long s long s */
 
6511
 
 
6512
static PyObject *
 
6513
gl_lRGBrange(PyObject *self, PyObject *args)
 
6514
{
 
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;
 
6542
}
 
6543
 
 
6544
/* void linesmooth long s */
 
6545
 
 
6546
static PyObject *
 
6547
gl_linesmooth(PyObject *self, PyObject *args)
 
6548
{
 
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;
 
6555
}
 
6556
 
 
6557
/* void lmcolor long s */
 
6558
 
 
6559
static PyObject *
 
6560
gl_lmcolor(PyObject *self, PyObject *args)
 
6561
{
 
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;
 
6568
}
 
6569
 
 
6570
/* void logicop long s */
 
6571
 
 
6572
static PyObject *
 
6573
gl_logicop(PyObject *self, PyObject *args)
 
6574
{
 
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;
 
6581
}
 
6582
 
 
6583
/* void lsetdepth long s long s */
 
6584
 
 
6585
static PyObject *
 
6586
gl_lsetdepth(PyObject *self, PyObject *args)
 
6587
{
 
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;
 
6597
}
 
6598
 
 
6599
/* void lshaderange short s short s long s long s */
 
6600
 
 
6601
static PyObject *
 
6602
gl_lshaderange(PyObject *self, PyObject *args)
 
6603
{
 
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;
 
6619
}
 
6620
 
 
6621
/* void n3f float s[3] */
 
6622
 
 
6623
static PyObject *
 
6624
gl_n3f(PyObject *self, PyObject *args)
 
6625
{
 
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;
 
6632
}
 
6633
 
 
6634
/* void noborder */
 
6635
 
 
6636
static PyObject *
 
6637
gl_noborder(PyObject *self, PyObject *args)
 
6638
{
 
6639
        noborder( );
 
6640
        Py_INCREF(Py_None);
 
6641
        return Py_None;
 
6642
}
 
6643
 
 
6644
/* void pntsmooth long s */
 
6645
 
 
6646
static PyObject *
 
6647
gl_pntsmooth(PyObject *self, PyObject *args)
 
6648
{
 
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;
 
6655
}
 
6656
 
 
6657
/* void readsource long s */
 
6658
 
 
6659
static PyObject *
 
6660
gl_readsource(PyObject *self, PyObject *args)
 
6661
{
 
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;
 
6668
}
 
6669
 
 
6670
/* void rectzoom float s float s */
 
6671
 
 
6672
static PyObject *
 
6673
gl_rectzoom(PyObject *self, PyObject *args)
 
6674
{
 
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;
 
6684
}
 
6685
 
 
6686
/* void sbox float s float s float s float s */
 
6687
 
 
6688
static PyObject *
 
6689
gl_sbox(PyObject *self, PyObject *args)
 
6690
{
 
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;
 
6706
}
 
6707
 
 
6708
/* void sboxi long s long s long s long s */
 
6709
 
 
6710
static PyObject *
 
6711
gl_sboxi(PyObject *self, PyObject *args)
 
6712
{
 
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;
 
6728
}
 
6729
 
 
6730
/* void sboxs short s short s short s short s */
 
6731
 
 
6732
static PyObject *
 
6733
gl_sboxs(PyObject *self, PyObject *args)
 
6734
{
 
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;
 
6750
}
 
6751
 
 
6752
/* void sboxf float s float s float s float s */
 
6753
 
 
6754
static PyObject *
 
6755
gl_sboxf(PyObject *self, PyObject *args)
 
6756
{
 
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;
 
6772
}
 
6773
 
 
6774
/* void sboxfi long s long s long s long s */
 
6775
 
 
6776
static PyObject *
 
6777
gl_sboxfi(PyObject *self, PyObject *args)
 
6778
{
 
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;
 
6794
}
 
6795
 
 
6796
/* void sboxfs short s short s short s short s */
 
6797
 
 
6798
static PyObject *
 
6799
gl_sboxfs(PyObject *self, PyObject *args)
 
6800
{
 
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;
 
6816
}
 
6817
 
 
6818
/* void setnurbsproperty long s float s */
 
6819
 
 
6820
static PyObject *
 
6821
gl_setnurbsproperty(PyObject *self, PyObject *args)
 
6822
{
 
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;
 
6832
}
 
6833
 
 
6834
/* void setpup long s long s long s */
 
6835
 
 
6836
static PyObject *
 
6837
gl_setpup(PyObject *self, PyObject *args)
 
6838
{
 
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;
 
6851
}
 
6852
 
 
6853
/* void smoothline long s */
 
6854
 
 
6855
static PyObject *
 
6856
gl_smoothline(PyObject *self, PyObject *args)
 
6857
{
 
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;
 
6864
}
 
6865
 
 
6866
/* void subpixel long s */
 
6867
 
 
6868
static PyObject *
 
6869
gl_subpixel(PyObject *self, PyObject *args)
 
6870
{
 
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;
 
6877
}
 
6878
 
 
6879
/* void swaptmesh */
 
6880
 
 
6881
static PyObject *
 
6882
gl_swaptmesh(PyObject *self, PyObject *args)
 
6883
{
 
6884
        swaptmesh( );
 
6885
        Py_INCREF(Py_None);
 
6886
        return Py_None;
 
6887
}
 
6888
 
 
6889
/* long swinopen long s */
 
6890
 
 
6891
static PyObject *
 
6892
gl_swinopen(PyObject *self, PyObject *args)
 
6893
{
 
6894
        long retval;
 
6895
        long arg1 ;
 
6896
        if (!getilongarg(args, 1, 0, &arg1))
 
6897
                return NULL;
 
6898
        retval = swinopen( arg1 );
 
6899
        return mknewlongobject(retval);
 
6900
}
 
6901
 
 
6902
/* void v2f float s[2] */
 
6903
 
 
6904
static PyObject *
 
6905
gl_v2f(PyObject *self, PyObject *args)
 
6906
{
 
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;
 
6913
}
 
6914
 
 
6915
/* void v2i long s[2] */
 
6916
 
 
6917
static PyObject *
 
6918
gl_v2i(PyObject *self, PyObject *args)
 
6919
{
 
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;
 
6926
}
 
6927
 
 
6928
/* void v2s short s[2] */
 
6929
 
 
6930
static PyObject *
 
6931
gl_v2s(PyObject *self, PyObject *args)
 
6932
{
 
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;
 
6939
}
 
6940
 
 
6941
/* void v3f float s[3] */
 
6942
 
 
6943
static PyObject *
 
6944
gl_v3f(PyObject *self, PyObject *args)
 
6945
{
 
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;
 
6952
}
 
6953
 
 
6954
/* void v3i long s[3] */
 
6955
 
 
6956
static PyObject *
 
6957
gl_v3i(PyObject *self, PyObject *args)
 
6958
{
 
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;
 
6965
}
 
6966
 
 
6967
/* void v3s short s[3] */
 
6968
 
 
6969
static PyObject *
 
6970
gl_v3s(PyObject *self, PyObject *args)
 
6971
{
 
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;
 
6978
}
 
6979
 
 
6980
/* void v4f float s[4] */
 
6981
 
 
6982
static PyObject *
 
6983
gl_v4f(PyObject *self, PyObject *args)
 
6984
{
 
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;
 
6991
}
 
6992
 
 
6993
/* void v4i long s[4] */
 
6994
 
 
6995
static PyObject *
 
6996
gl_v4i(PyObject *self, PyObject *args)
 
6997
{
 
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;
 
7004
}
 
7005
 
 
7006
/* void v4s short s[4] */
 
7007
 
 
7008
static PyObject *
 
7009
gl_v4s(PyObject *self, PyObject *args)
 
7010
{
 
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;
 
7017
}
 
7018
 
 
7019
/* void videocmd long s */
 
7020
 
 
7021
static PyObject *
 
7022
gl_videocmd(PyObject *self, PyObject *args)
 
7023
{
 
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;
 
7030
}
 
7031
 
 
7032
/* long windepth long s */
 
7033
 
 
7034
static PyObject *
 
7035
gl_windepth(PyObject *self, PyObject *args)
 
7036
{
 
7037
        long retval;
 
7038
        long arg1 ;
 
7039
        if (!getilongarg(args, 1, 0, &arg1))
 
7040
                return NULL;
 
7041
        retval = windepth( arg1 );
 
7042
        return mknewlongobject(retval);
 
7043
}
 
7044
 
 
7045
/* void wmpack long s */
 
7046
 
 
7047
static PyObject *
 
7048
gl_wmpack(PyObject *self, PyObject *args)
 
7049
{
 
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;
 
7056
}
 
7057
 
 
7058
/* void zdraw long s */
 
7059
 
 
7060
static PyObject *
 
7061
gl_zdraw(PyObject *self, PyObject *args)
 
7062
{
 
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;
 
7069
}
 
7070
 
 
7071
/* void zfunction long s */
 
7072
 
 
7073
static PyObject *
 
7074
gl_zfunction(PyObject *self, PyObject *args)
 
7075
{
 
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;
 
7082
}
 
7083
 
 
7084
/* void zsource long s */
 
7085
 
 
7086
static PyObject *
 
7087
gl_zsource(PyObject *self, PyObject *args)
 
7088
{
 
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;
 
7095
}
 
7096
 
 
7097
/* void zwritemask long s */
 
7098
 
 
7099
static PyObject *
 
7100
gl_zwritemask(PyObject *self, PyObject *args)
 
7101
{
 
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;
 
7108
}
 
7109
 
 
7110
/* void v2d double s[2] */
 
7111
 
 
7112
static PyObject *
 
7113
gl_v2d(PyObject *self, PyObject *args)
 
7114
{
 
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;
 
7121
}
 
7122
 
 
7123
/* void v3d double s[3] */
 
7124
 
 
7125
static PyObject *
 
7126
gl_v3d(PyObject *self, PyObject *args)
 
7127
{
 
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;
 
7134
}
 
7135
 
 
7136
/* void v4d double s[4] */
 
7137
 
 
7138
static PyObject *
 
7139
gl_v4d(PyObject *self, PyObject *args)
 
7140
{
 
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;
 
7147
}
 
7148
 
 
7149
/* void pixmode long s long s */
 
7150
 
 
7151
static PyObject *
 
7152
gl_pixmode(PyObject *self, PyObject *args)
 
7153
{
 
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;
 
7163
}
 
7164
 
 
7165
/* long qgetfd */
 
7166
 
 
7167
static PyObject *
 
7168
gl_qgetfd(PyObject *self, PyObject *args)
 
7169
{
 
7170
        long retval;
 
7171
        retval = qgetfd( );
 
7172
        return mknewlongobject(retval);
 
7173
}
 
7174
 
 
7175
/* void dither long s */
 
7176
 
 
7177
static PyObject *
 
7178
gl_dither(PyObject *self, PyObject *args)
 
7179
{
 
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;
 
7186
}
 
7187
 
 
7188
static struct PyMethodDef gl_methods[] = {
 
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 */
 
7622
};
 
7623
 
 
7624
void
 
7625
initgl(void)
 
7626
{
 
7627
    
 
7628
    if (PyErr_WarnPy3k("the gl module has been removed in "
 
7629
                       "Python 3.0", 2) < 0)
 
7630
        return;
 
7631
    
 
7632
        (void) Py_InitModule("gl", gl_methods);
 
7633
}