Initial revision
[blender.git] / source / blender / bpython / intern / opy_draw.c
1 /*  python.c      MIXED MODEL
2  * 
3  *  june 99
4  * $Id$
5  *
6  * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License
10  * as published by the Free Software Foundation; either version 2
11  * of the License, or (at your option) any later version. The Blender
12  * Foundation also sells licenses for use in proprietary software under
13  * the Blender License.  See http://www.blender.org/BL/ for information
14  * about this.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software Foundation,
23  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
24  *
25  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
26  * All rights reserved.
27  *
28  * The Original Code is: all of this file.
29  *
30  * Contributor(s): none yet.
31  *
32  * ***** END GPL/BL DUAL LICENSE BLOCK *****
33  */
34
35 #ifdef WIN32
36 #include "BLI_winstuff.h"
37 #endif
38
39 #include "MEM_guardedalloc.h"
40
41 #include "BMF_Api.h"
42
43 #include "DNA_screen_types.h"
44 #include "DNA_space_types.h"
45 #include "DNA_text_types.h"
46
47 #include "BKE_global.h"
48
49 #include "BIF_gl.h"
50 #include "BIF_screen.h"
51 #include "BIF_space.h"
52 #include "BIF_interface.h"
53 #include "BIF_mywindow.h"
54
55 #include "interface.h"
56 #include "mydevice.h"  /* for all the event constants */
57
58 #include "Python.h"
59 #include "BPY_macros.h"
60 #include "BPY_main.h"
61 #include "BPY_tools.h"
62
63 int disable_force_draw= 0;
64
65 /* hack to flag that window redraw has happened inside slider callback: */
66
67 static void exit_pydraw (SpaceText *st);
68 static uiBlock *Get_uiBlock (void);
69 void initDraw (void);
70
71 /* Button Object */
72
73 typedef struct _Button {
74         PyObject_VAR_HEAD
75
76         int type; /* 1 == int, 2 == float, 3 == string */
77         int slen; /* length of string (if type == 3) */
78         union {
79                 int asint;
80                 float asfloat;
81                 char *asstr;
82         } val;
83 } Button;
84
85
86 static void Button_dealloc(PyObject *self) {
87         Button *but= (Button*) self;
88
89         if(but->type==3) MEM_freeN(but->val.asstr);
90                 
91         PyMem_DEL(self);        
92 }
93
94 static PyObject *Button_getattr(PyObject *self, char *name) {
95         Button *but= (Button*) self;
96         
97         if(STREQ(name, "val")) {
98                 if (but->type==1)
99                         return Py_BuildValue("i", but->val.asint);                      
100                 else if (but->type==2) 
101                         return Py_BuildValue("f", but->val.asfloat);
102                 else if (but->type==3) 
103                         return Py_BuildValue("s", but->val.asstr);
104         }
105         PyErr_SetString(PyExc_AttributeError, name);
106         return NULL;
107 }
108
109 static int Button_setattr(PyObject *self,  char *name, PyObject *v) {
110         Button *but= (Button*) self;
111         
112         if(STREQ(name, "val")) {
113                 if  (but->type==1)
114                         PyArg_Parse(v, "i", &but->val.asint);
115                 else if (but->type==2)
116                         PyArg_Parse(v, "f", &but->val.asfloat);                 
117                 else if (but->type==3) {
118                         char *newstr;
119                         
120                         PyArg_Parse(v, "s", &newstr);
121                         strncpy(but->val.asstr, newstr, but->slen); 
122                 }
123         } else {
124                 PyErr_SetString(PyExc_AttributeError, name);
125                 return -1;
126         }
127         
128         return 0;
129 }
130
131 static PyObject *Button_repr(PyObject *self) {
132         return PyObject_Repr(Button_getattr(self, "val"));      
133 }
134
135 PyTypeObject Button_Type = {
136         PyObject_HEAD_INIT(NULL)
137         0,                                                              /*ob_size*/
138         "Button",                                               /*tp_name*/
139         sizeof(Button),                                 /*tp_basicsize*/
140         0,                                                              /*tp_itemsize*/
141         (destructor) Button_dealloc,    /*tp_dealloc*/
142         (printfunc)  0,                                 /*tp_print*/
143         (getattrfunc) Button_getattr,   /*tp_getattr*/
144         (setattrfunc) Button_setattr,   /*tp_setattr*/
145         (cmpfunc)  0,                                   /*tp_cmp*/
146         (reprfunc)  Button_repr,                /*tp_repr*/
147 };
148
149
150 static Button *newbutton (void) {
151         Button *but= (Button *) PyObject_NEW(Button, &Button_Type);
152         
153         return but;
154 }
155
156
157 /* GUI interface routines */
158
159 static void exit_pydraw(SpaceText *st) 
160 {
161         scrarea_queue_redraw(st->area);
162         
163         if (st) {       
164                 Py_XDECREF((PyObject *) st->py_draw);
165                 Py_XDECREF((PyObject *) st->py_event);
166                 Py_XDECREF((PyObject *) st->py_button);
167
168                 st->py_draw= st->py_event= st->py_button= NULL;
169         }
170 }
171
172 static void exec_callback(SpaceText *st, PyObject *callback, PyObject *args) 
173 {
174         PyObject *result= PyEval_CallObject(callback, args);
175         
176         if (result==NULL) {
177                 st->text->compiled= NULL;
178                 PyErr_Print();
179                 exit_pydraw(st);
180         }
181         Py_XDECREF(result);
182         Py_DECREF(args);
183 }
184
185 /* the handler for drawing routines (see Register method) */
186
187 void BPY_spacetext_do_pywin_draw(SpaceText *st) 
188 {
189         uiBlock *block;
190         char butblock[20];
191
192         sprintf(butblock, "win %d", curarea->win);
193         block= uiNewBlock(&curarea->uiblocks, butblock, UI_EMBOSSX, UI_HELV, curarea->win);
194         
195         if (st->py_draw) {
196                 glPushAttrib(GL_ALL_ATTRIB_BITS);
197                 exec_callback(st, st->py_draw, Py_BuildValue("()"));
198                 glPopAttrib();
199         } else {
200                 glClearColor(0.4375, 0.4375, 0.4375, 0.0); 
201                 glClear(GL_COLOR_BUFFER_BIT);
202         }
203
204         uiDrawBlock(block);
205
206         curarea->win_swap= WIN_BACK_OK;
207 }
208
209 /* the handler for button event routines (see Register method) */
210
211 static void spacetext_do_pywin_buttons(SpaceText *st, unsigned short event) {
212         if (st->py_button) {
213                 exec_callback(st, st->py_button, Py_BuildValue("(i)", event));
214         }
215 }
216
217 /* calls the generic event handling methods registered with Register */
218
219 void BPY_spacetext_do_pywin_event(SpaceText *st, unsigned short event, short val) {
220         if (event==QKEY && G.qual & (LR_ALTKEY|LR_CTRLKEY|LR_SHIFTKEY)) {
221                 exit_pydraw(st);
222                 return;
223         }
224
225         if (val) {
226                 if (uiDoBlocks(&curarea->uiblocks, event)!=UI_NOTHING ) event= 0;
227
228                 if (event==UI_BUT_EVENT) {
229                         spacetext_do_pywin_buttons(st, val);
230                 }
231         }
232                 
233         if (st->py_event) {
234                 exec_callback(st, st->py_event, Py_BuildValue("(ii)", event, val));
235         }
236 }
237
238 int BPY_spacetext_is_pywin(SpaceText *st) {
239         return (st->py_draw || st->py_event || st->py_button);
240 }
241
242 static char Method_Exit_doc[]= 
243 "() - Exit the windowing interface";
244 static PyObject *Method_Exit (PyObject *self, PyObject *args)
245 {       
246         SpaceText *st= curarea->spacedata.first;
247 #ifdef CLEAR_NAMESPACE  
248         PyObject *d;
249 #endif
250         BPY_TRY(PyArg_ParseTuple(args, ""));
251         
252         exit_pydraw(st);
253 #ifdef CLEAR_NAMESPACE  
254         d = st->py_globaldict; // The current window's global namespace dictionary
255         if (d) {
256                 PyDict_Clear(d);
257                 Py_DECREF(d); // release dictionary
258         }       
259 #endif
260         
261         return BPY_incr_ret(Py_None);
262 }
263
264 static char Method_Register_doc[]= 
265 "(draw, event, button) - Register callbacks for windowing\n\
266 \n\
267 (draw) A function to draw the screen, taking no arguments\n\
268 (event) A function to handle events, taking 2 arguments (evt, val)\n\
269         (evt) The event number\n\
270         (val) The value modifier (for key and mouse press/release)\n\
271 (button) A function to handle button events, taking 1 argument (evt)\n\
272         (evt) The button number\n\
273 \n\
274 A None object can be passed if a callback is unused.";
275
276 static PyObject *Method_Register (PyObject *self, PyObject *args)
277 {
278         PyObject *newdrawc= NULL, *neweventc= NULL, *newbuttonc= NULL;
279         SpaceText *st= curarea->spacedata.first;
280         
281         BPY_TRY(PyArg_ParseTuple(args, "O|OO", &newdrawc, &neweventc, &newbuttonc));
282
283         /* This is a hack again:
284          * Every python script should actually do a global variable cleanup at 
285          * the end of execution. 
286          * For scripts registering GUI callbacks, this does not work, because
287          * the global namespace of the interpreter still needs to be accessed
288          * from the callback. 
289          * Workaround: a text object has a flag which allows the global name
290          * space to be cleared at the end of the script. This flag should be
291          * normally set when executed with Alt-P. For a script registering with
292          * the GUI though, clear the flag and set it when the GUI mode is left
293          * (Method_Exit).
294          */
295
296         BPY_debug(("--- disable clear namespace"));
297
298         st->flags &= ~ST_CLEAR_NAMESPACE;
299
300
301         if (!PyCallable_Check(newdrawc)) newdrawc= NULL;
302         if (!PyCallable_Check(neweventc)) neweventc= NULL;
303         if (!PyCallable_Check(newbuttonc)) newbuttonc= NULL;
304
305         if (!(newdrawc || neweventc || newbuttonc))
306                 return BPY_incr_ret(Py_None);
307                 
308         exit_pydraw(st);
309
310         Py_XINCREF(newdrawc);
311         Py_XINCREF(neweventc);
312         Py_XINCREF(newbuttonc);
313         
314         st->py_draw= newdrawc;
315         st->py_event= neweventc;
316         st->py_button= newbuttonc;
317
318         scrarea_queue_redraw(st->area);
319
320         return BPY_incr_ret(Py_None);
321 }
322
323
324 static char Method_Redraw_doc[]= 
325 "([after]) - Queue a redraw event\n\
326 \n\
327 [after=0] Determines whether the redraw is processed before or after other input events.\n\
328 \n\
329 Redraw events are buffered so that regardless of how many events are queued\n\
330 the window only receives one redraw event.";
331
332 static PyObject *Method_Redraw (PyObject *self,  PyObject *args)
333 {
334         int after= 0;
335         
336         BPY_TRY(PyArg_ParseTuple(args, "|i", &after));
337
338         if (after) addafterqueue(curarea->win, REDRAW, 1);
339         else scrarea_queue_winredraw(curarea);
340         
341         return BPY_incr_ret(Py_None);
342 }
343
344
345 static char Method_Draw_doc[]= 
346 "() - Force an immediate redraw\n\
347 \n\
348 Forced redraws are not buffered, in other words the window is redrawn\n\
349 exactly once for everytime this function is called.";
350 static PyObject *Method_Draw (PyObject *self,  PyObject *args)
351 {
352         /* If forced drawing is disable queue a redraw event instead */
353         if (disable_force_draw) {
354                 scrarea_queue_winredraw(curarea);
355                 return BPY_incr_ret(Py_None);
356         }
357         
358         BPY_TRY(PyArg_ParseTuple(args, ""));
359
360         scrarea_do_windraw(curarea);
361
362         screen_swapbuffers();
363         
364         return BPY_incr_ret(Py_None);
365 }
366
367
368
369 static char Method_Create_doc[]= 
370 "(value) - Create a default Button object\n\
371 \n\
372 (value) - The value to store in the button\n\
373 \n\
374 Valid values are ints, floats, and strings";
375
376 static PyObject *Method_Create (PyObject *self,  PyObject *args)
377 {
378         Button *but;
379         PyObject *in;
380
381         BPY_TRY(PyArg_ParseTuple(args, "O", &in));
382         
383         but= newbutton();
384         if(PyFloat_Check(in)) {
385                 but->type= 2;
386                 but->val.asfloat= PyFloat_AsDouble(in);
387         } else if (PyInt_Check(in)) {           
388                 but->type= 1;
389                 but->val.asint= PyInt_AsLong(in);
390         } else if (PyString_Check(in)) {
391                 char *newstr= PyString_AsString(in);
392                 
393                 but->type= 3;
394                 but->slen= strlen(newstr);
395                 but->val.asstr= MEM_mallocN(but->slen+1, "button string");
396                 
397                 strcpy(but->val.asstr, newstr);
398         }
399                 
400         return (PyObject *) but;
401 }
402
403 static uiBlock *Get_uiBlock(void)
404 {
405         char butblock[32];
406         
407         sprintf(butblock, "win %d", curarea->win);
408
409         return uiGetBlock(butblock, curarea);
410 }
411
412 static char Method_Button_doc[]= 
413 "(name, event, x, y, width, height, [tooltip]) - Create a new Button (push) button\n\
414 \n\
415 (name) A string to display on the button\n\
416 (event) The event number to pass to the button event function when activated\n\
417 (x, y) The lower left coordinate of the button\n\
418 (width, height) The button width and height\n\
419 [tooltip=""] The button's tooltip";
420
421 static PyObject *Method_Button (PyObject *self,  PyObject *args)
422 {
423         uiBlock *block;
424         char *name, *tip= NULL;
425         int event;
426         int x, y, w, h;
427         
428         BPY_TRY(PyArg_ParseTuple(args, "siiiii|s", &name, &event, &x, &y, &w, &h, &tip));
429         
430         block= Get_uiBlock();
431
432         if(block) uiDefBut(block, BUT, event, name, x, y, w, h, 0, 0, 0, 0, 0, tip);
433         
434         return BPY_incr_ret(Py_None);
435 }
436
437 static char Method_Menu_doc[]=
438 "(name, event, x, y, width, height, default, [tooltip]) - Create a new Menu button\n\
439 \n\
440 (name) A string to display on the button\n\
441 (event) The event number to pass to the button event function when activated\n\
442 (x, y) The lower left coordinate of the button\n\
443 (width, height) The button width and height\n\
444 (default) The number of the option to be selected by default\n\
445 [tooltip=""] The button's tooltip\n\
446 \n\
447 The menu options are specified through the name of the\n\
448 button. Options are followed by a format code and seperated\n\
449 by the '|' (pipe) character.\n\
450 Valid format codes are\n\
451         %t - The option should be used as the title\n\
452         %xN - The option should set the integer N in the button value.";
453         
454 static PyObject *Method_Menu (PyObject *self,  PyObject *args)
455 {
456         uiBlock *block;
457         char *name, *tip= NULL;
458         int event, def;
459         int x, y, w, h;
460         Button *but;
461         
462         BPY_TRY(PyArg_ParseTuple(args, "siiiiii|s", &name, &event, &x, &y, &w, &h, &def, &tip));
463         
464         but= newbutton();
465         but->type= 1;
466         but->val.asint= def;
467         
468         block= Get_uiBlock();
469         if(block) uiDefButI(block, MENU, event, name, x, y, w, h, &but->val.asint, 0, 0, 0, 0, tip);
470         
471         return (PyObject *) but;
472 }
473
474 static char Method_Toggle_doc[]= 
475 "(name, event, x, y, width, height, default, [tooltip]) - Create a new Toggle button\n\
476 \n\
477 (name) A string to display on the button\n\
478 (event) The event number to pass to the button event function when activated\n\
479 (x, y) The lower left coordinate of the button\n\
480 (width, height) The button width and height\n\
481 (default) An integer (0 or 1) specifying the default state\n\
482 [tooltip=""] The button's tooltip";
483
484 static PyObject *Method_Toggle (PyObject *self,  PyObject *args)
485 {
486         uiBlock *block;
487         char *name, *tip= NULL;
488         int event;
489         int x, y, w, h, def;
490         Button *but;
491         
492         BPY_TRY(PyArg_ParseTuple(args, "siiiiii|s", &name, &event, &x, &y, &w, &h, &def, &tip));
493         
494         but= newbutton();
495         but->type= 1;
496         but->val.asint= def;
497         
498         block= Get_uiBlock();
499         if(block) uiDefButI(block, TOG, event, name, x, y, w, h, &but->val.asint, 0, 0, 0, 0, tip);
500         
501         return (PyObject *) but;
502 }
503
504
505 /* DO NOT TOUCH THIS FUNCTION !
506    Redrawing a slider inside its own callback routine is actually forbidden
507    with the current toolkit architecture (button routines are not reentrant).
508    But it works anyway.
509    XXX This is condemned to be dinosource in future - it's a hack.
510    */
511
512 static void py_slider_update(void *butv, void *data2_unused) 
513 {
514         uiBut *but= butv;
515
516         disable_force_draw= 1;
517                 /* 
518                 Disable forced drawing, otherwise the button object which
519                 is still being used might be deleted 
520                 */
521
522 //      UIfrontbuf = 0; 
523 //      spacetext_do_pywin_buttons(curarea->spacedata.first, but->retval);
524
525         g_window_redrawn = 0;
526         curarea->win_swap= WIN_BACK_OK; 
527         UIfrontbuf = 1; 
528         spacetext_do_pywin_buttons(curarea->spacedata.first, uiButGetRetVal(but));
529         UIfrontbuf = 0;
530
531         if (!g_window_redrawn) /* if Redraw already called */
532                 Windowmodule_Redraw(0, Py_BuildValue("(i)", SPACE_VIEW3D));
533
534         disable_force_draw= 0;
535 }
536
537 static char Method_Slider_doc[]= 
538 "(name, event, x, y, width, height, initial, min, max, [update, tooltip]) - Create a new Slider button\n\
539 \n\
540 (name) A string to display on the button\n\
541 (event) The event number to pass to the button event function when activated\n\
542 (x, y) The lower left coordinate of the button\n\
543 (width, height) The button width and height\n\
544 (initial, min, max) Three values (int or float) specifying the initial and limit values.\n\
545 [update=1] A value controlling whether the slider will emit events as it is edited.\n\
546                         A non-zero value (default) enables the events. A zero value supresses them.\n\
547 [tooltip=""] The button's tooltip";
548
549 static PyObject *Method_Slider (PyObject *self,  PyObject *args)
550 {
551         uiBlock *block;
552         char *name, *tip= NULL;
553         int event;
554         int x, y, w, h, realtime=1;
555         Button *but;
556         PyObject *mino, *maxo, *inio;
557         
558         BPY_TRY(PyArg_ParseTuple(args, "siiiiiOOO|is", &name, &event, &x, &y, &w, &h, &inio, &mino, &maxo, &realtime, &tip));
559
560         
561         but= newbutton();
562         if (PyFloat_Check(inio)) {
563                 float ini, min, max;
564
565                 ini= PyFloat_AsDouble(inio);
566                 min= PyFloat_AsDouble(mino);
567                 max= PyFloat_AsDouble(maxo);
568                                 
569                 but->type= 2;
570                 but->val.asfloat= ini;
571
572                 block= Get_uiBlock();
573                 if(block) {
574                         uiBut *ubut;
575                         ubut= uiDefButF(block, NUMSLI, event, name, x, y, w, h, &but->val.asfloat, min, max, 0, 0, tip);
576                         if (realtime) uiButSetFunc(ubut, py_slider_update, ubut, NULL);
577                 }               
578         } 
579         else {
580                 int ini, min, max;
581
582                 ini= PyInt_AsLong(inio);
583                 min= PyInt_AsLong(mino);
584                 max= PyInt_AsLong(maxo);
585                 
586                 but->type= 1;
587                 but->val.asint= ini;
588         
589                 block= Get_uiBlock();
590                 if(block) {
591                         uiBut *ubut;
592                         ubut= uiDefButI(block, NUMSLI, event, name, x, y, w, h, &but->val.asint, min, max, 0, 0, tip);
593                         if (realtime) uiButSetFunc(ubut, py_slider_update, ubut, NULL);
594                 }
595         }
596         return (PyObject *) but;
597 }
598
599 static char Method_Scrollbar_doc[]= 
600 "(event, x, y, width, height, initial, min, max, [update, tooltip]) - Create a new Scrollbar\n\
601 \n\
602 (event) The event number to pass to the button event function when activated\n\
603 (x, y) The lower left coordinate of the button\n\
604 (width, height) The button width and height\n\
605 (initial, min, max) Three values (int or float) specifying the initial and limit values.\n\
606 [update=1] A value controlling whether the slider will emit events as it is edited.\n\
607                         A non-zero value (default) enables the events. A zero value supresses them.\n\
608 [tooltip=""] The button's tooltip";
609
610 static PyObject *Method_Scrollbar (PyObject *self,  PyObject *args)
611 {
612         char *tip= NULL;
613         uiBlock *block;
614         int event;
615         int x, y, w, h, realtime=1;
616         Button *but;
617         PyObject *mino, *maxo, *inio;
618         float ini, min, max;
619
620         BPY_TRY(PyArg_ParseTuple(args, "iiiiiOOO|is", &event, &x, &y, &w, &h, &inio, &mino, &maxo, &realtime, &tip));
621         
622         if (!PyNumber_Check(inio) || !PyNumber_Check(inio) || !PyNumber_Check(inio))
623                 return BPY_err_ret_ob(PyExc_AttributeError, "expected numbers for initial, min, and max");
624                 
625         but= newbutton();
626         
627         if (PyFloat_Check(inio)) but->type= 2;
628         else but->type= 1;
629                 
630         ini= PyFloat_AsDouble(inio);
631         min= PyFloat_AsDouble(mino);
632         max= PyFloat_AsDouble(maxo);
633                                 
634         if (but->type==2) {
635                 but->val.asfloat= ini;
636                 block= Get_uiBlock();
637                 if(block) {
638                         uiBut *ubut;
639                         ubut= uiDefButF(block, SCROLL, event, "", x, y, w, h, &but->val.asfloat, min, max, 0, 0, tip);
640                         if (realtime) uiButSetFunc(ubut, py_slider_update, ubut, NULL);
641                 }
642         } else {
643                 but->val.asint= ini;
644                 block= Get_uiBlock();
645                 if(block) {
646                         uiBut *ubut;
647                         ubut= uiDefButI(block, SCROLL, event, "", x, y, w, h, &but->val.asint, min, max, 0, 0, tip);
648                         if (realtime) uiButSetFunc(ubut, py_slider_update, ubut, NULL);
649                 }
650         }
651         
652         return (PyObject *) but;
653 }
654
655 static char Method_Number_doc[]= 
656 "(name, event, x, y, width, height, initial, min, max, [tooltip]) - Create a new Number button\n\
657 \n\
658 (name) A string to display on the button\n\
659 (event) The event number to pass to the button event function when activated\n\
660 (x, y) The lower left coordinate of the button\n\
661 (width, height) The button width and height\n\
662 (initial, min, max) Three values (int or float) specifying the initial and limit values.\n\
663 [tooltip=""] The button's tooltip";
664
665 static PyObject *Method_Number (PyObject *self,  PyObject *args)
666 {
667         uiBlock *block;
668         char *name, *tip= NULL;
669         int event;
670         int x, y, w, h;
671         Button *but;
672         PyObject *mino, *maxo, *inio;
673         
674         BPY_TRY(PyArg_ParseTuple(args, "siiiiiOOO|s", &name, &event, &x, &y, &w, &h, &inio, &mino, &maxo, &tip));
675         
676         but= newbutton();
677         
678         if (PyFloat_Check(inio)) {
679                 float ini, min, max;
680
681                 ini= PyFloat_AsDouble(inio);
682                 min= PyFloat_AsDouble(mino);
683                 max= PyFloat_AsDouble(maxo);
684                                 
685                 but->type= 2;
686                 but->val.asfloat= ini;
687         
688                 block= Get_uiBlock();
689                 if(block) uiDefButF(block, NUM, event, name, x, y, w, h, &but->val.asfloat, min, max, 0, 0, tip);
690         } else {
691                 int ini, min, max;
692
693                 ini= PyInt_AsLong(inio);
694                 min= PyInt_AsLong(mino);
695                 max= PyInt_AsLong(maxo);
696                 
697                 but->type= 1;
698                 but->val.asint= ini;
699         
700                 block= Get_uiBlock();
701                 if(block) uiDefButI(block, NUM, event, name, x, y, w, h, &but->val.asint, min, max, 0, 0, tip);
702         }
703         
704         return (PyObject *) but;
705 }
706
707 static char Method_String_doc[]= 
708 "(name, event, x, y, width, height, initial, length, [tooltip]) - Create a new String button\n\
709 \n\
710 (name) A string to display on the button\n\
711 (event) The event number to pass to the button event function when activated\n\
712 (x, y) The lower left coordinate of the button\n\
713 (width, height) The button width and height\n\
714 (initial) The string to display initially\n\
715 (length) The maximum input length\n\
716 [tooltip=""] The button's tooltip";
717
718 static PyObject *Method_String (PyObject *self,  PyObject *args)
719 {
720         uiBlock *block;
721         char *name, *tip= NULL, *newstr;
722         int event;
723         int x, y, w, h, len;
724         Button *but;
725         
726         BPY_TRY(PyArg_ParseTuple(args, "siiiiisi|s", &name, &event, &x, &y, &w, &h, &newstr, &len, &tip));
727         
728         but= newbutton();
729         but->type= 3;
730         but->slen= len;
731         but->val.asstr= MEM_mallocN(len+1, "button string");
732         
733         strncpy(but->val.asstr, newstr, len);
734         but->val.asstr[len]= 0;
735         
736         block= Get_uiBlock();
737         if(block) uiDefBut(block, TEX, event, name, x, y, w, h, but->val.asstr, 0, len, 0, 0, tip);
738
739         return (PyObject *) but;
740 }
741
742 static char Method_Text_doc[]= 
743 "(text) - Draw text onscreen\n\
744 \n\
745 (text) The text to draw\n";
746 static PyObject *Method_Text (PyObject *self, PyObject *args)
747 {
748         char *text;
749         
750         BPY_TRY(PyArg_ParseTuple(args, "s", &text));
751         
752         BMF_DrawString(G.font, text);
753         
754         return BPY_incr_ret(Py_None);
755 }
756
757 #undef MethodDef
758 #define MethodDef(func) _MethodDef(func, Method)
759
760 static struct PyMethodDef Draw_methods[] = {
761         MethodDef(Create),
762         MethodDef(Button),
763         MethodDef(Toggle),
764         MethodDef(Menu),
765         MethodDef(Slider),
766         MethodDef(Scrollbar),
767         MethodDef(Number),
768         MethodDef(String),
769
770         MethodDef(Text),
771
772         MethodDef(Exit),
773         MethodDef(Redraw),
774         MethodDef(Draw),
775         MethodDef(Register),
776
777         {NULL, NULL}
778 };
779
780 PyObject *init_py_draw(void) 
781 {
782         PyObject *mod= Py_InitModule(SUBMODULE(Draw), Draw_methods);
783         PyObject *dict= PyModule_GetDict(mod);
784
785         Button_Type.ob_type= &PyType_Type;
786
787         BPY_ADDCONST(dict, LEFTMOUSE);
788         BPY_ADDCONST(dict, MIDDLEMOUSE);
789         BPY_ADDCONST(dict, RIGHTMOUSE);
790         BPY_ADDCONST(dict, MOUSEX);
791         BPY_ADDCONST(dict, MOUSEY);
792         BPY_ADDCONST(dict, TIMER0);
793         BPY_ADDCONST(dict, TIMER1);
794         BPY_ADDCONST(dict, TIMER2);
795         BPY_ADDCONST(dict, TIMER3);
796         BPY_ADDCONST(dict, KEYBD);
797         BPY_ADDCONST(dict, RAWKEYBD);
798         BPY_ADDCONST(dict, REDRAW);
799         BPY_ADDCONST(dict, INPUTCHANGE);
800         BPY_ADDCONST(dict, QFULL);
801         BPY_ADDCONST(dict, WINFREEZE);
802         BPY_ADDCONST(dict, WINTHAW);
803         BPY_ADDCONST(dict, WINCLOSE);
804         BPY_ADDCONST(dict, WINQUIT);
805 #ifndef IRISGL
806         BPY_ADDCONST(dict, Q_FIRSTTIME);
807 #endif
808         BPY_ADDCONST(dict, AKEY);
809         BPY_ADDCONST(dict, BKEY);
810         BPY_ADDCONST(dict, CKEY);
811         BPY_ADDCONST(dict, DKEY);
812         BPY_ADDCONST(dict, EKEY);
813         BPY_ADDCONST(dict, FKEY);
814         BPY_ADDCONST(dict, GKEY);
815         BPY_ADDCONST(dict, HKEY);
816         BPY_ADDCONST(dict, IKEY);
817         BPY_ADDCONST(dict, JKEY);
818         BPY_ADDCONST(dict, KKEY);
819         BPY_ADDCONST(dict, LKEY);
820         BPY_ADDCONST(dict, MKEY);
821         BPY_ADDCONST(dict, NKEY);
822         BPY_ADDCONST(dict, OKEY);
823         BPY_ADDCONST(dict, PKEY);
824         BPY_ADDCONST(dict, QKEY);
825         BPY_ADDCONST(dict, RKEY);
826         BPY_ADDCONST(dict, SKEY);
827         BPY_ADDCONST(dict, TKEY);
828         BPY_ADDCONST(dict, UKEY);
829         BPY_ADDCONST(dict, VKEY);
830         BPY_ADDCONST(dict, WKEY);
831         BPY_ADDCONST(dict, XKEY);
832         BPY_ADDCONST(dict, YKEY);
833         BPY_ADDCONST(dict, ZKEY);
834         BPY_ADDCONST(dict, ZEROKEY);
835         BPY_ADDCONST(dict, ONEKEY);
836         BPY_ADDCONST(dict, TWOKEY);
837         BPY_ADDCONST(dict, THREEKEY);
838         BPY_ADDCONST(dict, FOURKEY);
839         BPY_ADDCONST(dict, FIVEKEY);
840         BPY_ADDCONST(dict, SIXKEY);
841         BPY_ADDCONST(dict, SEVENKEY);
842         BPY_ADDCONST(dict, EIGHTKEY);
843         BPY_ADDCONST(dict, NINEKEY);
844         BPY_ADDCONST(dict, CAPSLOCKKEY);
845         BPY_ADDCONST(dict, LEFTCTRLKEY);
846         BPY_ADDCONST(dict, LEFTALTKEY);
847         BPY_ADDCONST(dict, RIGHTALTKEY);
848         BPY_ADDCONST(dict, RIGHTCTRLKEY);
849         BPY_ADDCONST(dict, RIGHTSHIFTKEY);
850         BPY_ADDCONST(dict, LEFTSHIFTKEY);
851         BPY_ADDCONST(dict, ESCKEY);
852         BPY_ADDCONST(dict, TABKEY);
853         BPY_ADDCONST(dict, RETKEY);
854         BPY_ADDCONST(dict, SPACEKEY);
855         BPY_ADDCONST(dict, LINEFEEDKEY);
856         BPY_ADDCONST(dict, BACKSPACEKEY);
857         BPY_ADDCONST(dict, DELKEY);
858         BPY_ADDCONST(dict, SEMICOLONKEY);
859         BPY_ADDCONST(dict, PERIODKEY);
860         BPY_ADDCONST(dict, COMMAKEY);
861         BPY_ADDCONST(dict, QUOTEKEY);
862         BPY_ADDCONST(dict, ACCENTGRAVEKEY);
863         BPY_ADDCONST(dict, MINUSKEY);
864         BPY_ADDCONST(dict, SLASHKEY);
865         BPY_ADDCONST(dict, BACKSLASHKEY);
866         BPY_ADDCONST(dict, EQUALKEY);
867         BPY_ADDCONST(dict, LEFTBRACKETKEY);
868         BPY_ADDCONST(dict, RIGHTBRACKETKEY);
869         BPY_ADDCONST(dict, LEFTARROWKEY);
870         BPY_ADDCONST(dict, DOWNARROWKEY);
871         BPY_ADDCONST(dict, RIGHTARROWKEY);
872         BPY_ADDCONST(dict, UPARROWKEY);
873         BPY_ADDCONST(dict, PAD2);
874         BPY_ADDCONST(dict, PAD4);
875         BPY_ADDCONST(dict, PAD6);
876         BPY_ADDCONST(dict, PAD8);
877         BPY_ADDCONST(dict, PAD1);
878         BPY_ADDCONST(dict, PAD3);
879         BPY_ADDCONST(dict, PAD5);
880         BPY_ADDCONST(dict, PAD7);
881         BPY_ADDCONST(dict, PAD9);
882         BPY_ADDCONST(dict, PADPERIOD);
883         BPY_ADDCONST(dict, PADSLASHKEY);
884         BPY_ADDCONST(dict, PADASTERKEY);
885         BPY_ADDCONST(dict, PAD0);
886         BPY_ADDCONST(dict, PADMINUS);
887         BPY_ADDCONST(dict, PADENTER);
888         BPY_ADDCONST(dict, PADPLUSKEY);
889         BPY_ADDCONST(dict, F1KEY);
890         BPY_ADDCONST(dict, F2KEY);
891         BPY_ADDCONST(dict, F3KEY);
892         BPY_ADDCONST(dict, F4KEY);
893         BPY_ADDCONST(dict, F5KEY);
894         BPY_ADDCONST(dict, F6KEY);
895         BPY_ADDCONST(dict, F7KEY);
896         BPY_ADDCONST(dict, F8KEY);
897         BPY_ADDCONST(dict, F9KEY);
898         BPY_ADDCONST(dict, F10KEY);
899         BPY_ADDCONST(dict, F11KEY);
900         BPY_ADDCONST(dict, F12KEY);
901         BPY_ADDCONST(dict, PAUSEKEY);
902         BPY_ADDCONST(dict, INSERTKEY);
903         BPY_ADDCONST(dict, HOMEKEY);
904         BPY_ADDCONST(dict, PAGEUPKEY);
905         BPY_ADDCONST(dict, PAGEDOWNKEY);
906         BPY_ADDCONST(dict, ENDKEY);
907         
908         return mod;
909 }
910
911
912 /* Buffer Object */
913
914 /* For Python access to OpenGL functions requiring
915  * a pointer.
916  */
917
918 PyTypeObject Buffer_Type;
919
920 typedef struct _Buffer {
921         PyObject_VAR_HEAD
922
923         PyObject *parent;
924         
925         int type; /* GL_BYTE, GL_SHORT, GL_INT, GL_FLOAT */
926         int ndimensions;
927         int *dimensions;
928         
929         union {
930                 char    *asbyte;
931                 short   *asshort;
932                 int             *asint;
933                 float   *asfloat;
934
935                 void    *asvoid;
936         } buf;
937 } Buffer;
938
939 static int type_size(int type) {
940         switch (type) {
941         case GL_BYTE: 
942                 return sizeof(char);
943         case GL_SHORT: 
944                 return sizeof(short);
945         case GL_INT: 
946                 return sizeof(int);
947         case GL_FLOAT: 
948                 return sizeof(float);
949         }
950         return -1;
951 }
952
953 static Buffer *make_buffer(int type, int ndimensions, int *dimensions) {
954         Buffer *buffer;
955         void *buf= NULL;
956         int i, size, length;
957         
958         length= 1;
959         for (i=0; i<ndimensions; i++) length*= dimensions[i];
960         
961         size= type_size(type);
962         
963         buf= MEM_mallocN(length*size, "Buffer buffer");
964         
965         buffer= (Buffer *) PyObject_NEW(Buffer, &Buffer_Type);
966         buffer->parent= NULL;
967         buffer->ndimensions= ndimensions;
968         buffer->dimensions= dimensions;
969         buffer->type= type;
970         buffer->buf.asvoid= buf;
971         
972         for (i= 0; i<length; i++) {
973                 if (type==GL_BYTE) 
974                         buffer->buf.asbyte[i]= 0;
975
976                 else if (type==GL_SHORT) 
977                         buffer->buf.asshort[i]= 0;
978
979                 else if (type==GL_INT) 
980                         buffer->buf.asint[i]= 0;
981
982                 else if (type==GL_FLOAT) 
983                         buffer->buf.asfloat[i]= 0.0;
984         }
985         
986         return buffer;
987 }
988
989 static int Buffer_ass_slice(PyObject *self, int begin, int end, PyObject *seq);
990
991 static char Method_Buffer_doc[]=
992 "(type, dimensions, [template]) - Create a new Buffer object\n\
993 \n\
994 (type) - The format to store data in\n\
995 (dimensions) - An int or sequence specifying the dimensions of the buffer\n\
996 [template] - A sequence of matching dimensions to the buffer to be created\n\
997         which will be used to initialize the Buffer.\n\
998 \n\
999 If a template is not passed in all fields will be initialized to 0.\n\
1000 \n\
1001 The type should be one of GL_BYTE, GL_SHORT, GL_INT, or GL_FLOAT.\n\
1002 If the dimensions are specified as an int a linear buffer will be\n\
1003 created. If a sequence is passed for the dimensions the buffer\n\
1004 will have len(sequence) dimensions, where the size for each dimension\n\
1005 is determined by the value in the sequence at that index.\n\
1006 \n\
1007 For example, passing [100, 100] will create a 2 dimensional\n\
1008 square buffer. Passing [16, 16, 32] will create a 3 dimensional\n\
1009 buffer which is twice as deep as it is wide or high.";
1010
1011 static PyObject *Method_Buffer (PyObject *self, PyObject *args)
1012 {
1013         PyObject *length_ob= NULL, *template= NULL;
1014         Buffer *buffer;
1015         
1016         int i, type;
1017         int *dimensions = 0, ndimensions = 0;
1018         
1019         BPY_TRY(PyArg_ParseTuple(args, "iO|O", &type, &length_ob, &template));
1020
1021         if (type!=GL_BYTE && type!=GL_SHORT && type!=GL_INT && type!=GL_FLOAT) {
1022                 PyErr_SetString(PyExc_AttributeError, "type");
1023                 return NULL;
1024         }
1025
1026         if (PyNumber_Check(length_ob)) {
1027                 ndimensions= 1;
1028                 dimensions= MEM_mallocN(ndimensions*sizeof(int), "Buffer dimensions");
1029                 dimensions[0]= PyInt_AsLong(length_ob);
1030
1031         } else if (PySequence_Check(length_ob)) {
1032                 ndimensions= PySequence_Length(length_ob);
1033                 dimensions= MEM_mallocN(ndimensions*sizeof(int), "Buffer dimensions");
1034                 
1035                 for (i=0; i<ndimensions; i++) {
1036                         PyObject *ob= PySequence_GetItem(length_ob, i);
1037                         
1038                         if (!PyNumber_Check(ob)) dimensions[i]= 1;
1039                         else dimensions[i]= PyInt_AsLong(ob);
1040                         
1041                         Py_DECREF(ob);
1042                 }
1043         }
1044         
1045         buffer= make_buffer(type, ndimensions, dimensions);
1046         if (template && ndimensions) {
1047                 if (Buffer_ass_slice((PyObject *) buffer, 0, dimensions[0], template)) {
1048                         Py_DECREF(buffer);
1049                         return NULL;
1050                 }
1051         }
1052         
1053         return (PyObject *) buffer;
1054 }
1055
1056 /**********/
1057
1058
1059 /* Buffer sequence methods */
1060
1061 static int Buffer_len(PyObject *self) {
1062         Buffer *buf= (Buffer *) self;
1063         
1064         return buf->dimensions[0];
1065 }
1066
1067 static PyObject *Buffer_item(PyObject *self, int i) {
1068         Buffer *buf= (Buffer *) self;
1069
1070         if (i >= buf->dimensions[0]) {
1071                 PyErr_SetString(PyExc_IndexError, "array index out of range");
1072                 return NULL;
1073         }
1074         
1075         if (buf->ndimensions==1) {
1076                 switch (buf->type) {
1077                 case GL_BYTE: return Py_BuildValue("b", buf->buf.asbyte[i]);
1078                 case GL_SHORT: return Py_BuildValue("h", buf->buf.asshort[i]);
1079                 case GL_INT: return Py_BuildValue("i", buf->buf.asint[i]);
1080                 case GL_FLOAT: return Py_BuildValue("f", buf->buf.asfloat[i]);
1081                 }
1082         } else {
1083                 Buffer *newbuf;
1084                 int j, length, size;
1085                 
1086                 length= 1;
1087                 for (j=1; j<buf->ndimensions; j++) {
1088                         length*= buf->dimensions[j];
1089                 }
1090                 size= type_size(buf->type);
1091                 
1092                 newbuf= (Buffer *) PyObject_NEW(Buffer, &Buffer_Type);
1093                 
1094                 Py_INCREF(self);
1095                 newbuf->parent= self;
1096                 
1097                 newbuf->ndimensions= buf->ndimensions-1;
1098                 newbuf->type= buf->type;
1099                 newbuf->buf.asvoid= buf->buf.asbyte + i*length*size;
1100
1101                 newbuf->dimensions= MEM_mallocN(newbuf->ndimensions*sizeof(int), "Buffer dimensions");
1102                 memcpy(newbuf->dimensions, buf->dimensions+1, newbuf->ndimensions*sizeof(int));
1103                 
1104                 return (PyObject *) newbuf;
1105         }
1106         
1107         return NULL;
1108 }
1109
1110 static PyObject *Buffer_slice(PyObject *self, int begin, int end)
1111 {
1112         Buffer *buf= (Buffer *) self;
1113         PyObject *list;
1114         int count;
1115         
1116         if (begin<0) begin= 0;
1117         if (end>buf->dimensions[0]) end= buf->dimensions[0];
1118         if (begin>end) begin= end;
1119                 
1120         list= PyList_New(end-begin);
1121
1122         for (count= begin; count<end; count++)
1123                 PyList_SetItem(list, count-begin, Buffer_item(self, count));
1124         
1125         return list;
1126 }
1127
1128 static int Buffer_ass_item(PyObject *self, int i, PyObject *v) {
1129         Buffer *buf= (Buffer *) self;
1130         
1131         if (i >= buf->dimensions[0]) {
1132                 PyErr_SetString(PyExc_IndexError, "array assignment index out of range");
1133                 return -1;
1134         }
1135         
1136         if (buf->ndimensions!=1) {
1137                 PyObject *row= Buffer_item(self, i);
1138                 int ret;
1139                 
1140                 if (!row) return -1;
1141
1142                 ret= Buffer_ass_slice(row, 0, buf->dimensions[1], v);
1143                 Py_DECREF(row);
1144                 
1145                 return ret;
1146         }
1147
1148         if (buf->type==GL_BYTE) {
1149                 if (!PyArg_Parse(v, "b;Coordinates must be ints", &buf->buf.asbyte[i]))
1150                         return -1;
1151                 
1152         } else if (buf->type==GL_SHORT) {
1153                 if (!PyArg_Parse(v, "h;Coordinates must be ints", &buf->buf.asshort[i]))
1154                         return -1;
1155                 
1156         } else if (buf->type==GL_INT) {
1157                 if (!PyArg_Parse(v, "i;Coordinates must be ints", &buf->buf.asint[i]))
1158                         return -1;
1159                 
1160         } else if (buf->type==GL_FLOAT) {
1161                 if (!PyArg_Parse(v, "f;Coordinates must be floats", &buf->buf.asfloat[i]))
1162                         return -1;
1163         }
1164         
1165         return 0;
1166 }
1167
1168 static int Buffer_ass_slice(PyObject *self, int begin, int end, PyObject *seq)
1169 {
1170         Buffer *buf= (Buffer *) self;
1171         PyObject *item;
1172         int count, err=0;
1173         
1174         if (begin<0) begin= 0;
1175         if (end>buf->dimensions[0]) end= buf->dimensions[0];
1176         if (begin>end) begin= end;
1177         
1178         if (!PySequence_Check(seq)) {
1179                 PyErr_SetString(PyExc_TypeError, "illegal argument type for built-in operation");
1180                 return -1;
1181         }
1182         
1183         if (PySequence_Length(seq)!=(end-begin)) {
1184                 PyErr_SetString(PyExc_TypeError, "size mismatch in assignment");
1185                 return -1;
1186         }
1187         
1188         for (count= begin; count<end; count++) {
1189                 item= PySequence_GetItem(seq, count-begin);
1190                 err= Buffer_ass_item(self, count, item);
1191                 Py_DECREF(item);
1192                 
1193                 if (err) break;
1194         }
1195
1196         return err;
1197 }
1198 static PySequenceMethods Buffer_SeqMethods = {
1199         (inquiry)                       Buffer_len,                     /*sq_length*/
1200         (binaryfunc)            0,                                      /*sq_concat*/
1201         (intargfunc)            0,                                      /*sq_repeat*/
1202         (intargfunc)            Buffer_item,            /*sq_item*/
1203         (intintargfunc)         Buffer_slice,           /*sq_slice*/
1204         (intobjargproc)         Buffer_ass_item,        /*sq_ass_item*/
1205         (intintobjargproc)      Buffer_ass_slice,       /*sq_ass_slice*/
1206 };
1207
1208
1209
1210 /**********/
1211
1212 static void Buffer_dealloc(PyObject *self) {
1213         Buffer *buf= (Buffer *) self;
1214
1215         if (buf->parent) Py_DECREF(buf->parent);
1216         else MEM_freeN(buf->buf.asvoid);
1217
1218         MEM_freeN(buf->dimensions);
1219         
1220         PyMem_DEL(self);        
1221 }
1222
1223 static PyObject *Buffer_tolist(PyObject *self) {
1224         int i, len= ((Buffer *)self)->dimensions[0];
1225         PyObject *list= PyList_New(len);
1226         
1227         for (i=0; i<len; i++) {
1228                 PyList_SetItem(list, i, Buffer_item(self, i));
1229         }
1230         
1231         return list;
1232 }
1233
1234 static PyObject *Buffer_dimensions(PyObject *self) {
1235         Buffer *buffer= (Buffer *) self;
1236         PyObject *list= PyList_New(buffer->ndimensions);
1237         int i;
1238                 
1239         for (i= 0; i<buffer->ndimensions; i++) {
1240                 PyList_SetItem(list, i, PyInt_FromLong(buffer->dimensions[i]));
1241         }
1242         
1243         return list;
1244 }
1245
1246 static PyObject *Buffer_getattr(PyObject *self, char *name) {
1247         if (strcmp(name, "list")==0) return Buffer_tolist(self);
1248         else if (strcmp(name, "dimensions")==0) return Buffer_dimensions(self);
1249         
1250         PyErr_SetString(PyExc_AttributeError, name);
1251         return NULL;
1252 }
1253
1254 static PyObject *Buffer_repr(PyObject *self) {
1255         PyObject *list= Buffer_tolist(self);
1256         PyObject *repr= PyObject_Repr(list);
1257         Py_DECREF(list);
1258         
1259         return repr;
1260 }
1261
1262 PyTypeObject Buffer_Type = {
1263         PyObject_HEAD_INIT(NULL)
1264         0,                                                              /*ob_size*/
1265         "Buffer",                                               /*tp_name*/
1266         sizeof(Buffer),                                 /*tp_basicsize*/
1267         0,                                                              /*tp_itemsize*/
1268         (destructor) Buffer_dealloc,    /*tp_dealloc*/
1269         (printfunc)  0,                                 /*tp_print*/
1270         (getattrfunc) Buffer_getattr,   /*tp_getattr*/
1271         (setattrfunc) 0,                                /*tp_setattr*/
1272         (cmpfunc) 0,                                    /*tp_compare*/
1273         (reprfunc) Buffer_repr,                 /*tp_repr*/
1274         0,                                                              /*tp_as_number*/
1275         &Buffer_SeqMethods,                             /*tp_as_sequence*/
1276 };
1277
1278 #ifndef __APPLE__
1279 /* By golly George! It looks like fancy pants macro time!!! */
1280
1281 /*
1282 #define int_str                         "i"
1283 #define int_var(number)         bgl_int##number
1284 #define int_ref(number)         &bgl_int##number
1285 #define int_def(number)         int int_var(number)
1286
1287 #define float_str                       "f"
1288 #define float_var(number)       bgl_float##number
1289 #define float_ref(number)       &bgl_float##number
1290 #define float_def(number)       float float_var(number)
1291 */
1292
1293 /* TYPE_str is the string to pass to Py_ArgParse (for the format) */
1294 /* TYPE_var is the name to pass to the GL function */
1295 /* TYPE_ref is the pointer to pass to Py_ArgParse (to store in) */
1296 /* TYPE_def is the C initialization of the variable */
1297
1298 #define void_str                        ""
1299 #define void_var(num)           
1300 #define void_ref(num)           &bgl_var##num
1301 #define void_def(num)           char bgl_var##num
1302
1303 #define buffer_str                      "O!"
1304 #define buffer_var(number)      (bgl_buffer##number)->buf.asvoid
1305 #define buffer_ref(number)      &Buffer_Type, &bgl_buffer##number
1306 #define buffer_def(number)      Buffer *bgl_buffer##number
1307
1308 /* GL Pointer fields, handled by buffer type */
1309 /* GLdoubleP, GLfloatP, GLintP, GLuintP, GLshortP */
1310
1311 #define GLbooleanP_str                  "O!"
1312 #define GLbooleanP_var(number)  (bgl_buffer##number)->buf.asvoid
1313 #define GLbooleanP_ref(number)  &Buffer_Type, &bgl_buffer##number
1314 #define GLbooleanP_def(number)  Buffer *bgl_buffer##number
1315
1316 #define GLbyteP_str                     "O!"
1317 #define GLbyteP_var(number)     (bgl_buffer##number)->buf.asvoid
1318 #define GLbyteP_ref(number)     &Buffer_Type, &bgl_buffer##number
1319 #define GLbyteP_def(number)     Buffer *bgl_buffer##number
1320
1321 #define GLubyteP_str                    "O!"
1322 #define GLubyteP_var(number)    (bgl_buffer##number)->buf.asvoid
1323 #define GLubyteP_ref(number)    &Buffer_Type, &bgl_buffer##number
1324 #define GLubyteP_def(number)    Buffer *bgl_buffer##number
1325
1326 #define GLintP_str                      "O!"
1327 #define GLintP_var(number)      (bgl_buffer##number)->buf.asvoid
1328 #define GLintP_ref(number)      &Buffer_Type, &bgl_buffer##number
1329 #define GLintP_def(number)      Buffer *bgl_buffer##number
1330
1331 #define GLuintP_str                     "O!"
1332 #define GLuintP_var(number)     (bgl_buffer##number)->buf.asvoid
1333 #define GLuintP_ref(number)     &Buffer_Type, &bgl_buffer##number
1334 #define GLuintP_def(number)     Buffer *bgl_buffer##number
1335
1336 #define GLshortP_str                    "O!"
1337 #define GLshortP_var(number)    (bgl_buffer##number)->buf.asvoid
1338 #define GLshortP_ref(number)    &Buffer_Type, &bgl_buffer##number
1339 #define GLshortP_def(number)    Buffer *bgl_buffer##number
1340
1341 #define GLushortP_str                   "O!"
1342 #define GLushortP_var(number)   (bgl_buffer##number)->buf.asvoid
1343 #define GLushortP_ref(number)   &Buffer_Type, &bgl_buffer##number
1344 #define GLushortP_def(number)   Buffer *bgl_buffer##number
1345
1346 #define GLfloatP_str                    "O!"
1347 #define GLfloatP_var(number)    (bgl_buffer##number)->buf.asvoid
1348 #define GLfloatP_ref(number)    &Buffer_Type, &bgl_buffer##number
1349 #define GLfloatP_def(number)    Buffer *bgl_buffer##number
1350
1351 #define GLdoubleP_str                   "O!"
1352 #define GLdoubleP_var(number)   (bgl_buffer##number)->buf.asvoid
1353 #define GLdoubleP_ref(number)   &Buffer_Type, &bgl_buffer##number
1354 #define GLdoubleP_def(number)   Buffer *bgl_buffer##number
1355
1356 #define GLclampfP_str                   "O!"
1357 #define GLclampfP_var(number)   (bgl_buffer##number)->buf.asvoid
1358 #define GLclampfP_ref(number)   &Buffer_Type, &bgl_buffer##number
1359 #define GLclampfP_def(number)   Buffer *bgl_buffer##number
1360
1361 #define GLvoidP_str                     "O!"
1362 #define GLvoidP_var(number)     (bgl_buffer##number)->buf.asvoid
1363 #define GLvoidP_ref(number)     &Buffer_Type, &bgl_buffer##number
1364 #define GLvoidP_def(number)     Buffer *bgl_buffer##number
1365
1366 #define buffer_str                      "O!"
1367 #define buffer_var(number)      (bgl_buffer##number)->buf.asvoid
1368 #define buffer_ref(number)      &Buffer_Type, &bgl_buffer##number
1369 #define buffer_def(number)      Buffer *bgl_buffer##number
1370
1371 /* The standard GL typedefs are used as prototypes, we can't
1372  * use the GL type directly because Py_ArgParse expects normal
1373  * C types.
1374  * 
1375  * Py_ArgParse doesn't grok writing into unsigned variables, 
1376  * so we use signed everything (even stuff that should be unsigned.
1377  */
1378  
1379 /* typedef unsigned int GLenum; */
1380 #define GLenum_str                      "i"
1381 #define GLenum_var(num)         bgl_var##num
1382 #define GLenum_ref(num)         &bgl_var##num
1383 #define GLenum_def(num)         /* unsigned */ int GLenum_var(num)
1384
1385 /* typedef unsigned int GLboolean; */
1386 #define GLboolean_str                   "b"
1387 #define GLboolean_var(num)              bgl_var##num
1388 #define GLboolean_ref(num)              &bgl_var##num
1389 #define GLboolean_def(num)              /* unsigned */ char GLboolean_var(num)
1390
1391 /* typedef unsigned int GLbitfield; */
1392 #define GLbitfield_str                  "i"
1393 #define GLbitfield_var(num)             bgl_var##num
1394 #define GLbitfield_ref(num)             &bgl_var##num
1395 #define GLbitfield_def(num)             /* unsigned */ int GLbitfield_var(num)
1396
1397 /* typedef signed char GLbyte; */
1398 #define GLbyte_str                              "b"
1399 #define GLbyte_var(num)                 bgl_var##num
1400 #define GLbyte_ref(num)                 &bgl_var##num
1401 #define GLbyte_def(num)                 signed char GLbyte_var(num)
1402
1403 /* typedef short GLshort; */
1404 #define GLshort_str                             "h"
1405 #define GLshort_var(num)                bgl_var##num
1406 #define GLshort_ref(num)                &bgl_var##num
1407 #define GLshort_def(num)                short GLshort_var(num)
1408
1409 /* typedef int GLint; */
1410 #define GLint_str                               "i"
1411 #define GLint_var(num)                  bgl_var##num
1412 #define GLint_ref(num)                  &bgl_var##num
1413 #define GLint_def(num)                  int GLint_var(num)
1414
1415 /* typedef int GLsizei; */
1416 #define GLsizei_str                             "i"
1417 #define GLsizei_var(num)                bgl_var##num
1418 #define GLsizei_ref(num)                &bgl_var##num
1419 #define GLsizei_def(num)                int GLsizei_var(num)
1420
1421 /* typedef unsigned char GLubyte; */
1422 #define GLubyte_str                             "b"
1423 #define GLubyte_var(num)                bgl_var##num
1424 #define GLubyte_ref(num)                &bgl_var##num
1425 #define GLubyte_def(num)                /* unsigned */ char GLubyte_var(num)
1426
1427 /* typedef unsigned short GLushort; */
1428 #define GLushort_str                    "h"
1429 #define GLushort_var(num)               bgl_var##num
1430 #define GLushort_ref(num)               &bgl_var##num
1431 #define GLushort_def(num)               /* unsigned */ short GLushort_var(num)
1432
1433 /* typedef unsigned int GLuint; */
1434 #define GLuint_str                              "i"
1435 #define GLuint_var(num)                 bgl_var##num
1436 #define GLuint_ref(num)                 &bgl_var##num
1437 #define GLuint_def(num)                 /* unsigned */ int GLuint_var(num)
1438
1439 /* typedef float GLfloat; */
1440 #define GLfloat_str                             "f"
1441 #define GLfloat_var(num)                bgl_var##num
1442 #define GLfloat_ref(num)                &bgl_var##num
1443 #define GLfloat_def(num)                float GLfloat_var(num)
1444
1445 /* typedef float GLclampf; */
1446 #define GLclampf_str                    "f"
1447 #define GLclampf_var(num)               bgl_var##num
1448 #define GLclampf_ref(num)               &bgl_var##num
1449 #define GLclampf_def(num)               float GLclampf_var(num)
1450
1451 /* typedef double GLdouble; */
1452 #define GLdouble_str                    "d"
1453 #define GLdouble_var(num)               bgl_var##num
1454 #define GLdouble_ref(num)               &bgl_var##num
1455 #define GLdouble_def(num)               double GLdouble_var(num)
1456
1457 /* typedef double GLclampd; */
1458 #define GLclampd_str                    "d"
1459 #define GLclampd_var(num)               bgl_var##num
1460 #define GLclampd_ref(num)               &bgl_var##num
1461 #define GLclampd_def(num)               double GLclampd_var(num)
1462
1463 /* typedef void GLvoid; */
1464 /* #define GLvoid_str                           "" */
1465 /* #define GLvoid_var(num)                      bgl_var##num */
1466 /* #define GLvoid_ref(num)                      &bgl_var##num */
1467 /* #define GLvoid_def(num)                      char bgl_var##num */
1468
1469 #define arg_def1(a1)                                    a1##_def(1)
1470 #define arg_def2(a1, a2)                                arg_def1(a1); a2##_def(2)
1471 #define arg_def3(a1, a2, a3)                    arg_def2(a1, a2); a3##_def(3)
1472 #define arg_def4(a1, a2, a3, a4)                arg_def3(a1, a2, a3); a4##_def(4)
1473 #define arg_def5(a1, a2, a3, a4, a5)    arg_def4(a1, a2, a3, a4); a5##_def(5)
1474 #define arg_def6(a1, a2, a3, a4, a5, a6)arg_def5(a1, a2, a3, a4, a5); a6##_def(6)
1475 #define arg_def7(a1, a2, a3, a4, a5, a6, a7)arg_def6(a1, a2, a3, a4, a5, a6); a7##_def(7)
1476 #define arg_def8(a1, a2, a3, a4, a5, a6, a7, a8)arg_def7(a1, a2, a3, a4, a5, a6, a7); a8##_def(8)
1477 #define arg_def9(a1, a2, a3, a4, a5, a6, a7, a8, a9)arg_def8(a1, a2, a3, a4, a5, a6, a7, a8); a9##_def(9)
1478 #define arg_def10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)arg_def9(a1, a2, a3, a4, a5, a6, a7, a8, a9); a10##_def(10)
1479
1480 #define arg_var1(a1)                                    a1##_var(1)
1481 #define arg_var2(a1, a2)                                arg_var1(a1), a2##_var(2)
1482 #define arg_var3(a1, a2, a3)                    arg_var2(a1, a2), a3##_var(3)
1483 #define arg_var4(a1, a2, a3, a4)                arg_var3(a1, a2, a3), a4##_var(4)
1484 #define arg_var5(a1, a2, a3, a4, a5)    arg_var4(a1, a2, a3, a4), a5##_var(5)
1485 #define arg_var6(a1, a2, a3, a4, a5, a6)arg_var5(a1, a2, a3, a4, a5), a6##_var(6)
1486 #define arg_var7(a1, a2, a3, a4, a5, a6, a7)arg_var6(a1, a2, a3, a4, a5, a6), a7##_var(7)
1487 #define arg_var8(a1, a2, a3, a4, a5, a6, a7, a8)arg_var7(a1, a2, a3, a4, a5, a6, a7), a8##_var(8)
1488 #define arg_var9(a1, a2, a3, a4, a5, a6, a7, a8, a9)arg_var8(a1, a2, a3, a4, a5, a6, a7, a8), a9##_var(9)
1489 #define arg_var10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)arg_var9(a1, a2, a3, a4, a5, a6, a7, a8, a9), a10##_var(10)
1490
1491 #define arg_ref1(a1)                                    a1##_ref(1)
1492 #define arg_ref2(a1, a2)                                arg_ref1(a1), a2##_ref(2)
1493 #define arg_ref3(a1, a2, a3)                    arg_ref2(a1, a2), a3##_ref(3)
1494 #define arg_ref4(a1, a2, a3, a4)                arg_ref3(a1, a2, a3), a4##_ref(4)
1495 #define arg_ref5(a1, a2, a3, a4, a5)    arg_ref4(a1, a2, a3, a4), a5##_ref(5)
1496 #define arg_ref6(a1, a2, a3, a4, a5, a6)arg_ref5(a1, a2, a3, a4, a5), a6##_ref(6)
1497 #define arg_ref7(a1, a2, a3, a4, a5, a6, a7)arg_ref6(a1, a2, a3, a4, a5, a6), a7##_ref(7)
1498 #define arg_ref8(a1, a2, a3, a4, a5, a6, a7, a8)arg_ref7(a1, a2, a3, a4, a5, a6, a7), a8##_ref(8)
1499 #define arg_ref9(a1, a2, a3, a4, a5, a6, a7, a8, a9)arg_ref8(a1, a2, a3, a4, a5, a6, a7, a8), a9##_ref(9)
1500 #define arg_ref10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)arg_ref9(a1, a2, a3, a4, a5, a6, a7, a8, a9), a10##_ref(10)
1501
1502 #define arg_str1(a1)                                    a1##_str
1503 #define arg_str2(a1, a2)                                arg_str1(a1) a2##_str
1504 #define arg_str3(a1, a2, a3)                    arg_str2(a1, a2) a3##_str
1505 #define arg_str4(a1, a2, a3, a4)                arg_str3(a1, a2, a3) a4##_str
1506 #define arg_str5(a1, a2, a3, a4, a5)    arg_str4(a1, a2, a3, a4) a5##_str
1507 #define arg_str6(a1, a2, a3, a4, a5, a6)arg_str5(a1, a2, a3, a4, a5) a6##_str
1508 #define arg_str7(a1, a2, a3, a4, a5, a6, a7)arg_str6(a1, a2, a3, a4, a5, a6) a7##_str
1509 #define arg_str8(a1, a2, a3, a4, a5, a6, a7, a8)arg_str7(a1, a2, a3, a4, a5, a6, a7) a8##_str
1510 #define arg_str9(a1, a2, a3, a4, a5, a6, a7, a8, a9)arg_str8(a1, a2, a3, a4, a5, a6, a7, a8) a9##_str
1511 #define arg_str10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)arg_str9(a1, a2, a3, a4, a5, a6, a7, a8, a9) a10##_str
1512
1513 #define ret_def_void    
1514 #define ret_set_void    
1515 #define ret_ret_void            return BPY_incr_ret(Py_None)
1516
1517 #define ret_def_GLint           int ret_int
1518 #define ret_set_GLint           ret_int= 
1519 #define ret_ret_GLint           return PyInt_FromLong(ret_int);
1520
1521 #define ret_def_GLuint          unsigned int ret_uint
1522 #define ret_set_GLuint          ret_uint= 
1523 #define ret_ret_GLuint          return PyInt_FromLong((long) ret_uint);
1524
1525 #define ret_def_GLenum          unsigned int ret_uint
1526 #define ret_set_GLenum          ret_uint= 
1527 #define ret_ret_GLenum          return PyInt_FromLong((long) ret_uint);
1528
1529 #define ret_def_GLboolean       unsigned char ret_bool
1530 #define ret_set_GLboolean       ret_bool= 
1531 #define ret_ret_GLboolean       return PyInt_FromLong((long) ret_bool);
1532
1533 #define ret_def_GLstring        const unsigned char *ret_str;
1534 #define ret_set_GLstring        ret_str= 
1535 #define ret_ret_GLstring        return PyString_FromString(ret_str);
1536
1537 #define BGL_Wrap(nargs, funcname, ret, arg_list) \
1538 static PyObject *Method_##funcname (PyObject *self, PyObject *args) {\
1539         arg_def##nargs arg_list; \
1540         ret_def_##ret; \
1541         if(!PyArg_ParseTuple(args, arg_str##nargs arg_list, arg_ref##nargs arg_list)) return NULL;\
1542         ret_set_##ret gl##funcname (arg_var##nargs arg_list);\
1543         ret_ret_##ret; \
1544 }
1545
1546 BGL_Wrap(2, Accum,                                      void,           (GLenum, GLfloat))
1547 BGL_Wrap(2, AlphaFunc,                          void,           (GLenum, GLclampf))
1548 BGL_Wrap(3, AreTexturesResident,        GLboolean,      (GLsizei, GLuintP, GLbooleanP))
1549 BGL_Wrap(1, Begin,                                      void,           (GLenum))
1550 BGL_Wrap(2, BindTexture,                        void,           (GLenum, GLuint))
1551 BGL_Wrap(7, Bitmap,                             void,           (GLsizei, GLsizei, GLfloat, GLfloat, GLfloat, GLfloat, GLubyteP))
1552 BGL_Wrap(2, BlendFunc,                          void,           (GLenum, GLenum))
1553 BGL_Wrap(1, CallList,                           void,           (GLuint))
1554 BGL_Wrap(3, CallLists,                          void,           (GLsizei, GLenum, GLvoidP))
1555 BGL_Wrap(1, Clear,                                      void,           (GLbitfield))
1556 BGL_Wrap(4, ClearAccum,                         void,           (GLfloat, GLfloat, GLfloat, GLfloat))
1557 BGL_Wrap(4, ClearColor,                         void,           (GLclampf, GLclampf, GLclampf, GLclampf))
1558 BGL_Wrap(1, ClearDepth,                         void,           (GLclampd))
1559 BGL_Wrap(1, ClearIndex,                         void,           (GLfloat))
1560 BGL_Wrap(1, ClearStencil,                       void,           (GLint))
1561 BGL_Wrap(2, ClipPlane,                          void,           (GLenum, GLdoubleP))
1562 BGL_Wrap(3, Color3b,                            void,           (GLbyte, GLbyte, GLbyte))
1563 BGL_Wrap(1, Color3bv,                           void,           (GLbyteP))
1564 BGL_Wrap(3, Color3d,                            void,           (GLdouble, GLdouble, GLdouble))
1565 BGL_Wrap(1, Color3dv,                           void,           (GLdoubleP))
1566 BGL_Wrap(3, Color3f,                            void,           (GLfloat, GLfloat, GLfloat))
1567 BGL_Wrap(1, Color3fv,                           void,           (GLfloatP))
1568 BGL_Wrap(3, Color3i,                            void,           (GLint, GLint, GLint))
1569 BGL_Wrap(1, Color3iv,                           void,           (GLintP))
1570 BGL_Wrap(3, Color3s,                            void,           (GLshort, GLshort, GLshort))
1571 BGL_Wrap(1, Color3sv,                           void,           (GLshortP))
1572 BGL_Wrap(3, Color3ub,                           void,           (GLubyte, GLubyte, GLubyte))
1573 BGL_Wrap(1, Color3ubv,                          void,           (GLubyteP))
1574 BGL_Wrap(3, Color3ui,                           void,           (GLuint, GLuint, GLuint))
1575 BGL_Wrap(1, Color3uiv,                          void,           (GLuintP))
1576 BGL_Wrap(3, Color3us,                           void,           (GLushort, GLushort, GLushort))
1577 BGL_Wrap(1, Color3usv,                          void,           (GLushortP))
1578 BGL_Wrap(4, Color4b,                            void,           (GLbyte, GLbyte, GLbyte, GLbyte))
1579 BGL_Wrap(1, Color4bv,                           void,           (GLbyteP))
1580 BGL_Wrap(4, Color4d,                            void,           (GLdouble, GLdouble, GLdouble, GLdouble))
1581 BGL_Wrap(1, Color4dv,                           void,           (GLdoubleP))
1582 BGL_Wrap(4, Color4f,                            void,           (GLfloat, GLfloat, GLfloat, GLfloat))
1583 BGL_Wrap(1, Color4fv,                           void,           (GLfloatP))
1584 BGL_Wrap(4, Color4i,                            void,           (GLint, GLint, GLint, GLint))
1585 BGL_Wrap(1, Color4iv,                           void,           (GLintP))
1586 BGL_Wrap(4, Color4s,                            void,           (GLshort, GLshort, GLshort, GLshort))
1587 BGL_Wrap(1, Color4sv,                           void,           (GLshortP))
1588 BGL_Wrap(4, Color4ub,                           void,           (GLubyte, GLubyte, GLubyte, GLubyte))
1589 BGL_Wrap(1, Color4ubv,                          void,           (GLubyteP))
1590 BGL_Wrap(4, Color4ui,                           void,           (GLuint, GLuint, GLuint, GLuint))
1591 BGL_Wrap(1, Color4uiv,                          void,           (GLuintP))
1592 BGL_Wrap(4, Color4us,                           void,           (GLushort, GLushort, GLushort, GLushort))
1593 BGL_Wrap(1, Color4usv,                          void,           (GLushortP))
1594 BGL_Wrap(4, ColorMask,                          void,           (GLboolean, GLboolean, GLboolean, GLboolean))
1595 BGL_Wrap(2, ColorMaterial,                      void,           (GLenum, GLenum))
1596 BGL_Wrap(5, CopyPixels,                         void,           (GLint, GLint, GLsizei, GLsizei, GLenum))
1597 BGL_Wrap(1, CullFace,                           void,           (GLenum))
1598 BGL_Wrap(2, DeleteLists,                        void,           (GLuint, GLsizei))
1599 BGL_Wrap(2, DeleteTextures,                     void,           (GLsizei, GLuintP))
1600 BGL_Wrap(1, DepthFunc,                          void,           (GLenum))
1601 BGL_Wrap(1, DepthMask,                          void,           (GLboolean))
1602 BGL_Wrap(2, DepthRange,                         void,           (GLclampd, GLclampd))
1603 BGL_Wrap(1, Disable,                            void,           (GLenum))
1604 BGL_Wrap(1, DrawBuffer,                         void,           (GLenum))
1605 BGL_Wrap(5, DrawPixels,                         void,           (GLsizei, GLsizei, GLenum, GLenum, GLvoidP))
1606 BGL_Wrap(1, EdgeFlag,                           void,           (GLboolean))
1607 BGL_Wrap(1, EdgeFlagv,                          void,           (GLbooleanP))
1608 BGL_Wrap(1, Enable,                             void,           (GLenum))
1609 BGL_Wrap(1, End,                                        void,           (void))
1610 BGL_Wrap(1, EndList,                            void,           (void))
1611 BGL_Wrap(1, EvalCoord1d,                        void,           (GLdouble))
1612 BGL_Wrap(1, EvalCoord1dv,                       void,           (GLdoubleP))
1613 BGL_Wrap(1, EvalCoord1f,                        void,           (GLfloat))
1614 BGL_Wrap(1, EvalCoord1fv,                       void,           (GLfloatP))
1615 BGL_Wrap(2, EvalCoord2d,                        void,           (GLdouble, GLdouble))
1616 BGL_Wrap(1, EvalCoord2dv,                       void,           (GLdoubleP))
1617 BGL_Wrap(2, EvalCoord2f,                        void,           (GLfloat, GLfloat))
1618 BGL_Wrap(1, EvalCoord2fv,                       void,           (GLfloatP))
1619 BGL_Wrap(3, EvalMesh1,                          void,           (GLenum, GLint, GLint))
1620 BGL_Wrap(5, EvalMesh2,                          void,           (GLenum, GLint, GLint, GLint, GLint))
1621 BGL_Wrap(1, EvalPoint1,                         void,           (GLint))
1622 BGL_Wrap(2, EvalPoint2,                         void,           (GLint, GLint))
1623 BGL_Wrap(3, FeedbackBuffer,             void,           (GLsizei, GLenum, GLfloatP))
1624 BGL_Wrap(1, Finish,                             void,           (void))
1625 BGL_Wrap(1, Flush,                                      void,           (void))
1626 BGL_Wrap(2, Fogf,                                       void,           (GLenum, GLfloat))
1627 BGL_Wrap(2, Fogfv,                                      void,           (GLenum, GLfloatP))
1628 BGL_Wrap(2, Fogi,                                       void,           (GLenum, GLint))
1629 BGL_Wrap(2, Fogiv,                                      void,           (GLenum, GLintP))
1630 BGL_Wrap(1, FrontFace,                          void,           (GLenum))
1631 BGL_Wrap(6, Frustum,                            void,           (GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble))
1632 BGL_Wrap(1, GenLists,                           GLuint,         (GLsizei))
1633 BGL_Wrap(2, GenTextures,                        void,           (GLsizei, GLuintP))
1634 BGL_Wrap(2, GetBooleanv,                        void,           (GLenum, GLbooleanP))
1635 BGL_Wrap(2, GetClipPlane,                       void,           (GLenum, GLdoubleP))
1636 BGL_Wrap(2, GetDoublev,                         void,           (GLenum, GLdoubleP))
1637 BGL_Wrap(1, GetError,                           GLenum,         (void))
1638 BGL_Wrap(2, GetFloatv,                          void,           (GLenum, GLfloatP))
1639 BGL_Wrap(2, GetIntegerv,                        void,           (GLenum, GLintP))
1640 BGL_Wrap(3, GetLightfv,                         void,           (GLenum, GLenum, GLfloatP))
1641 BGL_Wrap(3, GetLightiv,                         void,           (GLenum, GLenum, GLintP))
1642 BGL_Wrap(3, GetMapdv,                           void,           (GLenum, GLenum, GLdoubleP))
1643 BGL_Wrap(3, GetMapfv,                           void,           (GLenum, GLenum, GLfloatP))
1644 BGL_Wrap(3, GetMapiv,                           void,           (GLenum, GLenum, GLintP))
1645 BGL_Wrap(3, GetMaterialfv,                      void,           (GLenum, GLenum, GLfloatP))
1646 BGL_Wrap(3, GetMaterialiv,                      void,           (GLenum, GLenum, GLintP))
1647 BGL_Wrap(2, GetPixelMapfv,                      void,           (GLenum, GLfloatP))
1648 BGL_Wrap(2, GetPixelMapuiv,             void,           (GLenum, GLuintP))
1649 BGL_Wrap(2, GetPixelMapusv,             void,           (GLenum, GLushortP))
1650 BGL_Wrap(1, GetPolygonStipple,          void,           (GLubyteP))
1651 BGL_Wrap(1, GetString,                          GLstring,       (GLenum))
1652 BGL_Wrap(3, GetTexEnvfv,                        void,           (GLenum, GLenum, GLfloatP))
1653 BGL_Wrap(3, GetTexEnviv,                        void,           (GLenum, GLenum, GLintP))
1654 BGL_Wrap(3, GetTexGendv,                        void,           (GLenum, GLenum, GLdoubleP))
1655 BGL_Wrap(3, GetTexGenfv,                        void,           (GLenum, GLenum, GLfloatP))
1656 BGL_Wrap(3, GetTexGeniv,                        void,           (GLenum, GLenum, GLintP))
1657 BGL_Wrap(5, GetTexImage,                        void,           (GLenum, GLint, GLenum, GLenum, GLvoidP))
1658 BGL_Wrap(4, GetTexLevelParameterfv, void,               (GLenum, GLint, GLenum, GLfloatP))
1659 BGL_Wrap(4, GetTexLevelParameteriv, void,               (GLenum, GLint, GLenum, GLintP))
1660 BGL_Wrap(3, GetTexParameterfv,          void,           (GLenum, GLenum, GLfloatP))
1661 BGL_Wrap(3, GetTexParameteriv,          void,           (GLenum, GLenum, GLintP))
1662 BGL_Wrap(2, Hint,                                       void,           (GLenum, GLenum))
1663 BGL_Wrap(1, IndexMask,                          void,           (GLuint))
1664 BGL_Wrap(1, Indexd,                             void,           (GLdouble))
1665 BGL_Wrap(1, Indexdv,                            void,           (GLdoubleP))
1666 BGL_Wrap(1, Indexf,                             void,           (GLfloat))
1667 BGL_Wrap(1, Indexfv,                            void,           (GLfloatP))
1668 BGL_Wrap(1, Indexi,                             void,           (GLint))
1669 BGL_Wrap(1, Indexiv,                            void,           (GLintP))
1670 BGL_Wrap(1, Indexs,                             void,           (GLshort))
1671 BGL_Wrap(1, Indexsv,                            void,           (GLshortP))
1672 BGL_Wrap(1, InitNames,                          void,           (void))
1673 BGL_Wrap(1, IsEnabled,                          GLboolean,      (GLenum))
1674 BGL_Wrap(1, IsList,                             GLboolean,      (GLuint))
1675 BGL_Wrap(1, IsTexture,                          GLboolean,      (GLuint))
1676 BGL_Wrap(2, LightModelf,                        void,           (GLenum, GLfloat))
1677 BGL_Wrap(2, LightModelfv,                       void,           (GLenum, GLfloatP))
1678 BGL_Wrap(2, LightModeli,                        void,           (GLenum, GLint))
1679 BGL_Wrap(2, LightModeliv,                       void,           (GLenum, GLintP))
1680 BGL_Wrap(3, Lightf,                             void,           (GLenum, GLenum, GLfloat))
1681 BGL_Wrap(3, Lightfv,                            void,           (GLenum, GLenum, GLfloatP))
1682 BGL_Wrap(3, Lighti,                             void,           (GLenum, GLenum, GLint))
1683 BGL_Wrap(3, Lightiv,                            void,           (GLenum, GLenum, GLintP))
1684 BGL_Wrap(2, LineStipple,                        void,           (GLint, GLushort))
1685 BGL_Wrap(1, LineWidth,                          void,           (GLfloat))
1686 BGL_Wrap(1, ListBase,                           void,           (GLuint))
1687 BGL_Wrap(1, LoadIdentity,                       void,           (void))
1688 BGL_Wrap(1, LoadMatrixd,                        void,           (GLdoubleP))
1689 BGL_Wrap(1, LoadMatrixf,                        void,           (GLfloatP))
1690 BGL_Wrap(1, LoadName,                           void,           (GLuint))
1691 BGL_Wrap(1, LogicOp,                            void,           (GLenum))
1692 BGL_Wrap(6, Map1d,                                      void,           (GLenum, GLdouble, GLdouble, GLint, GLint, GLdoubleP))
1693 BGL_Wrap(6, Map1f,                                      void,           (GLenum, GLfloat, GLfloat, GLint, GLint, GLfloatP))
1694 BGL_Wrap(10, Map2d,                             void,           (GLenum, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, GLdoubleP))
1695 BGL_Wrap(10, Map2f,                             void,           (GLenum, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, GLfloatP))
1696 BGL_Wrap(3, MapGrid1d,                          void,           (GLint, GLdouble, GLdouble))
1697 BGL_Wrap(3, MapGrid1f,                          void,           (GLint, GLfloat, GLfloat))
1698 BGL_Wrap(6, MapGrid2d,                          void,           (GLint, GLdouble, GLdouble, GLint, GLdouble, GLdouble))
1699 BGL_Wrap(6, MapGrid2f,                          void,           (GLint, GLfloat, GLfloat, GLint, GLfloat, GLfloat))
1700 BGL_Wrap(3, Materialf,                          void,           (GLenum, GLenum, GLfloat))
1701 BGL_Wrap(3, Materialfv,                         void,           (GLenum, GLenum, GLfloatP))
1702 BGL_Wrap(3, Materiali,                          void,           (GLenum, GLenum, GLint))
1703 BGL_Wrap(3, Materialiv,                         void,           (GLenum, GLenum, GLintP))
1704 BGL_Wrap(1, MatrixMode,                         void,           (GLenum))
1705 BGL_Wrap(1, MultMatrixd,                        void,           (GLdoubleP))
1706 BGL_Wrap(1, MultMatrixf,                        void,           (GLfloatP))
1707 BGL_Wrap(2, NewList,                            void,           (GLuint, GLenum))
1708 BGL_Wrap(3, Normal3b,                           void,           (GLbyte, GLbyte, GLbyte))
1709 BGL_Wrap(1, Normal3bv,                          void,           (GLbyteP))
1710 BGL_Wrap(3, Normal3d,                           void,           (GLdouble, GLdouble, GLdouble))
1711 BGL_Wrap(1, Normal3dv,                          void,           (GLdoubleP))
1712 BGL_Wrap(3, Normal3f,                           void,           (GLfloat, GLfloat, GLfloat))
1713 BGL_Wrap(1, Normal3fv,                          void,           (GLfloatP))
1714 BGL_Wrap(3, Normal3i,                           void,           (GLint, GLint, GLint))
1715 BGL_Wrap(1, Normal3iv,                          void,           (GLintP))
1716 BGL_Wrap(3, Normal3s,                           void,           (GLshort, GLshort, GLshort))
1717 BGL_Wrap(1, Normal3sv,                          void,           (GLshortP))
1718 BGL_Wrap(6, Ortho,                                      void,           (GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble))
1719 BGL_Wrap(1, PassThrough,                        void,           (GLfloat))
1720 BGL_Wrap(3, PixelMapfv,                         void,           (GLenum, GLint, GLfloatP))
1721 BGL_Wrap(3, PixelMapuiv,                        void,           (GLenum, GLint, GLuintP))
1722 BGL_Wrap(3, PixelMapusv,                        void,           (GLenum, GLint, GLushortP))
1723 BGL_Wrap(2, PixelStoref,                        void,           (GLenum, GLfloat))
1724 BGL_Wrap(2, PixelStorei,                        void,           (GLenum, GLint))
1725 BGL_Wrap(2, PixelTransferf,             void,           (GLenum, GLfloat))
1726 BGL_Wrap(2, PixelTransferi,             void,           (GLenum, GLint))
1727 BGL_Wrap(2, PixelZoom,                          void,           (GLfloat, GLfloat))
1728 BGL_Wrap(1, PointSize,                          void,           (GLfloat))
1729 BGL_Wrap(2, PolygonMode,                        void,           (GLenum, GLenum))
1730 BGL_Wrap(2, PolygonOffset,                      void,           (GLfloat, GLfloat))
1731 BGL_Wrap(1, PolygonStipple,             void,           (GLubyteP))
1732 BGL_Wrap(1, PopAttrib,                          void,           (void))
1733 BGL_Wrap(1, PopMatrix,                          void,           (void))
1734 BGL_Wrap(1, PopName,                            void,           (void))
1735 BGL_Wrap(3, PrioritizeTextures,         void,           (GLsizei, GLuintP, GLclampfP))
1736 BGL_Wrap(1, PushAttrib,                         void,           (GLbitfield))
1737 BGL_Wrap(1, PushMatrix,                         void,           (void))
1738 BGL_Wrap(1, PushName,                           void,           (GLuint))
1739 BGL_Wrap(2, RasterPos2d,                        void,           (GLdouble, GLdouble))
1740 BGL_Wrap(1, RasterPos2dv,                       void,           (GLdoubleP))
1741 BGL_Wrap(2, RasterPos2f,                        void,           (GLfloat, GLfloat))
1742 BGL_Wrap(1, RasterPos2fv,                       void,           (GLfloatP))
1743 BGL_Wrap(2, RasterPos2i,                        void,           (GLint, GLint))
1744 BGL_Wrap(1, RasterPos2iv,                       void,           (GLintP))
1745 BGL_Wrap(2, RasterPos2s,                        void,           (GLshort, GLshort))
1746 BGL_Wrap(1, RasterPos2sv,                       void,           (GLshortP))
1747 BGL_Wrap(3, RasterPos3d,                        void,           (GLdouble, GLdouble, GLdouble))
1748 BGL_Wrap(1, RasterPos3dv,                       void,           (GLdoubleP))
1749 BGL_Wrap(3, RasterPos3f,                        void,           (GLfloat, GLfloat, GLfloat))
1750 BGL_Wrap(1, RasterPos3fv,                       void,           (GLfloatP))
1751 BGL_Wrap(3, RasterPos3i,                        void,           (GLint, GLint, GLint))
1752 BGL_Wrap(1, RasterPos3iv,                       void,           (GLintP))
1753 BGL_Wrap(3, RasterPos3s,                        void,           (GLshort, GLshort, GLshort))
1754 BGL_Wrap(1, RasterPos3sv,                       void,           (GLshortP))
1755 BGL_Wrap(4, RasterPos4d,                        void,           (GLdouble, GLdouble, GLdouble, GLdouble))
1756 BGL_Wrap(1, RasterPos4dv,                       void,           (GLdoubleP))
1757 BGL_Wrap(4, RasterPos4f,                        void,           (GLfloat, GLfloat, GLfloat, GLfloat))
1758 BGL_Wrap(1, RasterPos4fv,                       void,           (GLfloatP))
1759 BGL_Wrap(4, RasterPos4i,                        void,           (GLint, GLint, GLint, GLint))
1760 BGL_Wrap(1, RasterPos4iv,                       void,           (GLintP))
1761 BGL_Wrap(4, RasterPos4s,                        void,           (GLshort, GLshort, GLshort, GLshort))
1762 BGL_Wrap(1, RasterPos4sv,                       void,           (GLshortP))
1763 BGL_Wrap(1, ReadBuffer,                         void,           (GLenum))
1764 BGL_Wrap(7, ReadPixels,                         void,           (GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoidP))
1765 BGL_Wrap(4, Rectd,                                      void,           (GLdouble, GLdouble, GLdouble, GLdouble))
1766 BGL_Wrap(2, Rectdv,                             void,           (GLdoubleP, GLdoubleP))
1767 BGL_Wrap(4, Rectf,                                      void,           (GLfloat, GLfloat, GLfloat, GLfloat))
1768 BGL_Wrap(2, Rectfv,                             void,           (GLfloatP, GLfloatP))
1769 BGL_Wrap(4, Recti,                                      void,           (GLint, GLint, GLint, GLint))
1770 BGL_Wrap(2, Rectiv,                             void,           (GLintP, GLintP))
1771 BGL_Wrap(4, Rects,                                      void,           (GLshort, GLshort, GLshort, GLshort))
1772 BGL_Wrap(2, Rectsv,                             void,           (GLshortP, GLshortP))
1773 BGL_Wrap(1, RenderMode,                         GLint,          (GLenum))
1774 BGL_Wrap(4, Rotated,                            void,           (GLdouble, GLdouble, GLdouble, GLdouble))
1775 BGL_Wrap(4, Rotatef,                            void,           (GLfloat, GLfloat, GLfloat, GLfloat))
1776 BGL_Wrap(3, Scaled,                             void,           (GLdouble, GLdouble, GLdouble))
1777 BGL_Wrap(3, Scalef,                             void,           (GLfloat, GLfloat, GLfloat))
1778 BGL_Wrap(4, Scissor,                            void,           (GLint, GLint, GLsizei, GLsizei))
1779 BGL_Wrap(2, SelectBuffer,                       void,           (GLsizei, GLuintP))
1780 BGL_Wrap(1, ShadeModel,                         void,           (GLenum))
1781 BGL_Wrap(3, StencilFunc,                        void,           (GLenum, GLint, GLuint))
1782 BGL_Wrap(1, StencilMask,                        void,           (GLuint))
1783 BGL_Wrap(3, StencilOp,                          void,           (GLenum, GLenum, GLenum))
1784 BGL_Wrap(1, TexCoord1d,                         void,           (GLdouble))
1785 BGL_Wrap(1, TexCoord1dv,                        void,           (GLdoubleP))
1786 BGL_Wrap(1, TexCoord1f,                         void,           (GLfloat))
1787 BGL_Wrap(1, TexCoord1fv,                        void,           (GLfloatP))
1788 BGL_Wrap(1, TexCoord1i,                         void,           (GLint))
1789 BGL_Wrap(1, TexCoord1iv,                        void,           (GLintP))
1790 BGL_Wrap(1, TexCoord1s,                         void,           (GLshort))
1791 BGL_Wrap(1, TexCoord1sv,                        void,           (GLshortP))
1792 BGL_Wrap(2, TexCoord2d,                         void,           (GLdouble, GLdouble))
1793 BGL_Wrap(1, TexCoord2dv,                        void,           (GLdoubleP))
1794 BGL_Wrap(2, TexCoord2f,                         void,           (GLfloat, GLfloat))
1795 BGL_Wrap(1, TexCoord2fv,                        void,           (GLfloatP))
1796 BGL_Wrap(2, TexCoord2i,                         void,           (GLint, GLint))
1797 BGL_Wrap(1, TexCoord2iv,                        void,           (GLintP))
1798 BGL_Wrap(2, TexCoord2s,                         void,           (GLshort, GLshort))
1799 BGL_Wrap(1, TexCoord2sv,                        void,           (GLshortP))
1800 BGL_Wrap(3, TexCoord3d,                         void,           (GLdouble, GLdouble, GLdouble))
1801 BGL_Wrap(1, TexCoord3dv,                        void,           (GLdoubleP))
1802 BGL_Wrap(3, TexCoord3f,                         void,           (GLfloat, GLfloat, GLfloat))
1803 BGL_Wrap(1, TexCoord3fv,                        void,           (GLfloatP))
1804 BGL_Wrap(3, TexCoord3i,                         void,           (GLint, GLint, GLint))
1805 BGL_Wrap(1, TexCoord3iv,                        void,           (GLintP))
1806 BGL_Wrap(3, TexCoord3s,                         void,           (GLshort, GLshort, GLshort))
1807 BGL_Wrap(1, TexCoord3sv,                        void,           (GLshortP))
1808 BGL_Wrap(4, TexCoord4d,                         void,           (GLdouble, GLdouble, GLdouble, GLdouble))
1809 BGL_Wrap(1, TexCoord4dv,                        void,           (GLdoubleP))
1810 BGL_Wrap(4, TexCoord4f,                         void,           (GLfloat, GLfloat, GLfloat, GLfloat))
1811 BGL_Wrap(1, TexCoord4fv,                        void,           (GLfloatP))
1812 BGL_Wrap(4, TexCoord4i,                         void,           (GLint, GLint, GLint, GLint))
1813 BGL_Wrap(1, TexCoord4iv,                        void,           (GLintP))
1814 BGL_Wrap(4, TexCoord4s,                         void,           (GLshort, GLshort, GLshort, GLshort))
1815 BGL_Wrap(1, TexCoord4sv,                        void,           (GLshortP))
1816 BGL_Wrap(3, TexEnvf,                            void,           (GLenum, GLenum, GLfloat))
1817 BGL_Wrap(3, TexEnvfv,                           void,           (GLenum, GLenum, GLfloatP))
1818 BGL_Wrap(3, TexEnvi,                            void,           (GLenum, GLenum, GLint))
1819 BGL_Wrap(3, TexEnviv,                           void,           (GLenum, GLenum, GLintP))
1820 BGL_Wrap(3, TexGend,                            void,           (GLenum, GLenum, GLdouble))
1821 BGL_Wrap(3, TexGendv,                           void,           (GLenum, GLenum, GLdoubleP))
1822 BGL_Wrap(3, TexGenf,                            void,           (GLenum, GLenum, GLfloat))
1823 BGL_Wrap(3, TexGenfv,                           void,           (GLenum, GLenum, GLfloatP))
1824 BGL_Wrap(3, TexGeni,                            void,           (GLenum, GLenum, GLint))
1825 BGL_Wrap(3, TexGeniv,                           void,           (GLenum, GLenum, GLintP))
1826 BGL_Wrap(8, TexImage1D,                         void,           (GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, GLvoidP))
1827 BGL_Wrap(9, TexImage2D,                         void,           (GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, GLvoidP))
1828 BGL_Wrap(3, TexParameterf,                      void,           (GLenum, GLenum, GLfloat))
1829 BGL_Wrap(3, TexParameterfv,             void,           (GLenum, GLenum, GLfloatP))
1830 BGL_Wrap(3, TexParameteri,                      void,           (GLenum, GLenum, GLint))
1831 BGL_Wrap(3, TexParameteriv,             void,           (GLenum, GLenum, GLintP))
1832 BGL_Wrap(3, Translated,                         void,           (GLdouble, GLdouble, GLdouble))
1833 BGL_Wrap(3, Translatef,                         void,           (GLfloat, GLfloat, GLfloat))
1834 BGL_Wrap(2, Vertex2d,                           void,           (GLdouble, GLdouble))
1835 BGL_Wrap(1, Vertex2dv,                          void,           (GLdoubleP))
1836 BGL_Wrap(2, Vertex2f,                           void,           (GLfloat, GLfloat))
1837 BGL_Wrap(1, Vertex2fv,                          void,           (GLfloatP))
1838 BGL_Wrap(2, Vertex2i,                           void,           (GLint, GLint))
1839 BGL_Wrap(1, Vertex2iv,                          void,           (GLintP))
1840 BGL_Wrap(2, Vertex2s,                           void,           (GLshort, GLshort))
1841 BGL_Wrap(1, Vertex2sv,                          void,           (GLshortP))
1842 BGL_Wrap(3, Vertex3d,                           void,           (GLdouble, GLdouble, GLdouble))
1843 BGL_Wrap(1, Vertex3dv,                          void,           (GLdoubleP))
1844 BGL_Wrap(3, Vertex3f,                           void,           (GLfloat, GLfloat, GLfloat))
1845 BGL_Wrap(1, Vertex3fv,                          void,           (GLfloatP))
1846 BGL_Wrap(3, Vertex3i,                           void,           (GLint, GLint, GLint))
1847 BGL_Wrap(1, Vertex3iv,                          void,           (GLintP))
1848 BGL_Wrap(3, Vertex3s,                           void,           (GLshort, GLshort, GLshort))
1849 BGL_Wrap(1, Vertex3sv,                          void,           (GLshortP))
1850 BGL_Wrap(4, Vertex4d,                           void,           (GLdouble, GLdouble, GLdouble, GLdouble))
1851 BGL_Wrap(1, Vertex4dv,                          void,           (GLdoubleP))
1852 BGL_Wrap(4, Vertex4f,                           void,           (GLfloat, GLfloat, GLfloat, GLfloat))
1853 BGL_Wrap(1, Vertex4fv,                          void,           (GLfloatP))
1854 BGL_Wrap(4, Vertex4i,                           void,           (GLint, GLint, GLint, GLint))
1855 BGL_Wrap(1, Vertex4iv,                          void,           (GLintP))
1856 BGL_Wrap(4, Vertex4s,                           void,           (GLshort, GLshort, GLshort, GLshort))
1857 BGL_Wrap(1, Vertex4sv,                          void,           (GLshortP))
1858 BGL_Wrap(4, Viewport,                           void,           (GLint, GLint, GLsizei, GLsizei))
1859 #endif
1860
1861 /* XXX */
1862 #undef MethodDef
1863 #define MethodDef(func) {"gl"#func, Method_##func, METH_VARARGS}
1864
1865 static struct PyMethodDef BGL_methods[] = {
1866         {"Buffer", Method_Buffer, METH_VARARGS, Method_Buffer_doc}, 
1867 #ifndef __APPLE__
1868         MethodDef( Accum),
1869         MethodDef( AlphaFunc),
1870         MethodDef( AreTexturesResident), 
1871         MethodDef( Begin),
1872         MethodDef( BindTexture), 
1873         MethodDef( Bitmap),
1874         MethodDef( BlendFunc),
1875         MethodDef( CallList),
1876         MethodDef( CallLists),
1877         MethodDef( Clear),
1878         MethodDef( ClearAccum),
1879         MethodDef( ClearColor),
1880         MethodDef( ClearDepth),
1881         MethodDef( ClearIndex),
1882         MethodDef( ClearStencil),
1883         MethodDef( ClipPlane),
1884         MethodDef( Color3b),
1885         MethodDef( Color3bv),
1886         MethodDef( Color3d),
1887         MethodDef( Color3dv),
1888         MethodDef( Color3f),
1889         MethodDef( Color3fv),
1890         MethodDef( Color3i),
1891         MethodDef( Color3iv),
1892         MethodDef( Color3s),
1893         MethodDef( Color3sv),
1894         MethodDef( Color3ub),
1895         MethodDef( Color3ubv),
1896         MethodDef( Color3ui),
1897         MethodDef( Color3uiv),
1898         MethodDef( Color3us),
1899         MethodDef( Color3usv),
1900         MethodDef( Color4b),
1901         MethodDef( Color4bv),
1902         MethodDef( Color4d),
1903         MethodDef( Color4dv),
1904         MethodDef( Color4f),
1905         MethodDef( Color4fv),
1906         MethodDef( Color4i),
1907         MethodDef( Color4iv),
1908         MethodDef( Color4s),
1909         MethodDef( Color4sv),
1910         MethodDef( Color4ub),
1911         MethodDef( Color4ubv),
1912         MethodDef( Color4ui),
1913         MethodDef( Color4uiv),
1914         MethodDef( Color4us),
1915         MethodDef( Color4usv),
1916         MethodDef( ColorMask),
1917         MethodDef( ColorMaterial),
1918         MethodDef( CopyPixels),
1919         MethodDef( CullFace),
1920         MethodDef( DeleteLists),
1921         MethodDef( DeleteTextures),
1922         MethodDef( DepthFunc),
1923         MethodDef( DepthMask),
1924         MethodDef( DepthRange),
1925         MethodDef( Disable),
1926         MethodDef( DrawBuffer),
1927         MethodDef( DrawPixels),
1928         MethodDef( EdgeFlag),
1929         MethodDef( EdgeFlagv),
1930         MethodDef( Enable),
1931         MethodDef( End),
1932         MethodDef( EndList),
1933         MethodDef( EvalCoord1d),
1934         MethodDef( EvalCoord1dv),
1935         MethodDef( EvalCoord1f),
1936         MethodDef( EvalCoord1fv),
1937         MethodDef( EvalCoord2d),
1938         MethodDef( EvalCoord2dv),
1939         MethodDef( EvalCoord2f),
1940         MethodDef( EvalCoord2fv),
1941         MethodDef( EvalMesh1),
1942         MethodDef( EvalMesh2),
1943         MethodDef( EvalPoint1),
1944         MethodDef( EvalPoint2),
1945         MethodDef( FeedbackBuffer),
1946         MethodDef( Finish),
1947         MethodDef( Flush),
1948         MethodDef( Fogf),
1949         MethodDef( Fogfv),
1950         MethodDef( Fogi),
1951         MethodDef( Fogiv),
1952         MethodDef( FrontFace),
1953         MethodDef( Frustum),
1954         MethodDef( GenLists),
1955         MethodDef( GenTextures), 
1956         MethodDef( GetBooleanv),
1957         MethodDef( GetClipPlane),
1958         MethodDef( GetDoublev),
1959         MethodDef( GetError),
1960         MethodDef( GetFloatv),
1961         MethodDef( GetIntegerv),
1962         MethodDef( GetLightfv),
1963         MethodDef( GetLightiv),
1964         MethodDef( GetMapdv),
1965         MethodDef( GetMapfv),
1966         MethodDef( GetMapiv),
1967         MethodDef( GetMaterialfv),
1968         MethodDef( GetMaterialiv),
1969         MethodDef( GetPixelMapfv),
1970         MethodDef( GetPixelMapuiv),
1971         MethodDef( GetPixelMapusv),
1972         MethodDef( GetPolygonStipple),
1973         MethodDef( GetString),
1974         MethodDef( GetTexEnvfv),
1975         MethodDef( GetTexEnviv),
1976         MethodDef( GetTexGendv),
1977         MethodDef( GetTexGenfv),
1978         MethodDef( GetTexGeniv),
1979         MethodDef( GetTexImage),
1980         MethodDef( GetTexLevelParameterfv),
1981         MethodDef( GetTexLevelParameteriv),
1982         MethodDef( GetTexParameterfv),
1983         MethodDef( GetTexParameteriv),
1984         MethodDef( Hint),
1985         MethodDef( IndexMask),
1986         MethodDef( Indexd),
1987         MethodDef( Indexdv),
1988         MethodDef( Indexf),
1989         MethodDef( Indexfv),
1990         MethodDef( Indexi),
1991         MethodDef( Indexiv),
1992         MethodDef( Indexs),
1993         MethodDef( Indexsv),
1994         MethodDef( InitNames),
1995         MethodDef( IsEnabled),
1996         MethodDef( IsList),
1997         MethodDef( IsTexture), 
1998         MethodDef( LightModelf),
1999         MethodDef( LightModelfv),
2000         MethodDef( LightModeli),
2001         MethodDef( LightModeliv),
2002         MethodDef( Lightf),
2003         MethodDef( Lightfv),
2004         MethodDef( Lighti),
2005         MethodDef( Lightiv),
2006         MethodDef( LineStipple),
2007         MethodDef( LineWidth),
2008         MethodDef( ListBase),
2009         MethodDef( LoadIdentity),
2010         MethodDef( LoadMatrixd),
2011         MethodDef( LoadMatrixf),
2012         MethodDef( LoadName),
2013         MethodDef( LogicOp),
2014         MethodDef( Map1d),
2015         MethodDef( Map1f),
2016         MethodDef( Map2d),
2017         MethodDef( Map2f),
2018         MethodDef( MapGrid1d),
2019         MethodDef( MapGrid1f),
2020         MethodDef( MapGrid2d),
2021         MethodDef( MapGrid2f),
2022         MethodDef( Materialf),
2023         MethodDef( Materialfv),
2024         MethodDef( Materiali),
2025         MethodDef( Materialiv),
2026         MethodDef( MatrixMode),
2027         MethodDef( MultMatrixd),
2028         MethodDef( MultMatrixf),
2029         MethodDef( NewList),
2030         MethodDef( Normal3b),
2031         MethodDef( Normal3bv),
2032         MethodDef( Normal3d),
2033         MethodDef( Normal3dv),
2034         MethodDef( Normal3f),
2035         MethodDef( Normal3fv),
2036         MethodDef( Normal3i),
2037         MethodDef( Normal3iv),
2038         MethodDef( Normal3s),
2039         MethodDef( Normal3sv),
2040         MethodDef( Ortho),
2041         MethodDef( PassThrough),
2042         MethodDef( PixelMapfv),
2043         MethodDef( PixelMapuiv),
2044         MethodDef( PixelMapusv),
2045         MethodDef( PixelStoref),
2046         MethodDef( PixelStorei),
2047         MethodDef( PixelTransferf),
2048         MethodDef( PixelTransferi),
2049         MethodDef( PixelZoom),
2050         MethodDef( PointSize),
2051         MethodDef( PolygonMode),
2052         MethodDef( PolygonOffset),
2053         MethodDef( PolygonStipple),
2054         MethodDef( PopAttrib),
2055         MethodDef( PopMatrix),
2056         MethodDef( PopName),
2057         MethodDef( PrioritizeTextures), 
2058         MethodDef( PushAttrib),
2059         MethodDef( PushMatrix),
2060         MethodDef( PushName),
2061         MethodDef( RasterPos2d),
2062         MethodDef( RasterPos2dv),
2063         MethodDef( RasterPos2f),
2064         MethodDef( RasterPos2fv),
2065         MethodDef( RasterPos2i),
2066         MethodDef( RasterPos2iv),
2067         MethodDef( RasterPos2s),
2068         MethodDef( RasterPos2sv),
2069         MethodDef( RasterPos3d),
2070         MethodDef( RasterPos3dv),
2071         MethodDef( RasterPos3f),
2072         MethodDef( RasterPos3fv),
2073         MethodDef( RasterPos3i),
2074         MethodDef( RasterPos3iv),
2075         MethodDef( RasterPos3s),
2076         MethodDef( RasterPos3sv),
2077         MethodDef( RasterPos4d),
2078         MethodDef( RasterPos4dv),
2079         MethodDef( RasterPos4f),
2080         MethodDef( RasterPos4fv),
2081         MethodDef( RasterPos4i),
2082         MethodDef( RasterPos4iv),
2083         MethodDef( RasterPos4s),
2084         MethodDef( RasterPos4sv),
2085         MethodDef( ReadBuffer),
2086         MethodDef( ReadPixels),
2087         MethodDef( Rectd),
2088         MethodDef( Rectdv),
2089         MethodDef( Rectf),
2090         MethodDef( Rectfv),
2091         MethodDef( Recti),
2092         MethodDef( Rectiv),
2093         MethodDef( Rects),
2094         MethodDef( Rectsv),
2095         MethodDef( RenderMode),
2096         MethodDef( Rotated),
2097         MethodDef( Rotatef),
2098         MethodDef( Scaled),
2099         MethodDef( Scalef),
2100         MethodDef( Scissor),
2101         MethodDef( SelectBuffer),
2102         MethodDef( ShadeModel),
2103         MethodDef( StencilFunc),
2104         MethodDef( StencilMask),
2105         MethodDef( StencilOp),
2106         MethodDef( TexCoord1d),
2107         MethodDef( TexCoord1dv),
2108         MethodDef( TexCoord1f),
2109         MethodDef( TexCoord1fv),
2110         MethodDef( TexCoord1i),
2111         MethodDef( TexCoord1iv),
2112         MethodDef( TexCoord1s),
2113         MethodDef( TexCoord1sv),
2114         MethodDef( TexCoord2d),
2115         MethodDef( TexCoord2dv),
2116         MethodDef( TexCoord2f),
2117         MethodDef( TexCoord2fv),
2118         MethodDef( TexCoord2i),
2119         MethodDef( TexCoord2iv),
2120         MethodDef( TexCoord2s),
2121         MethodDef( TexCoord2sv),
2122         MethodDef( TexCoord3d),
2123         MethodDef( TexCoord3dv),
2124         MethodDef( TexCoord3f),
2125         MethodDef( TexCoord3fv),
2126         MethodDef( TexCoord3i),
2127         MethodDef( TexCoord3iv),
2128         MethodDef( TexCoord3s),
2129         MethodDef( TexCoord3sv),
2130         MethodDef( TexCoord4d),
2131         MethodDef( TexCoord4dv),
2132         MethodDef( TexCoord4f),
2133         MethodDef( TexCoord4fv),
2134         MethodDef( TexCoord4i),
2135         MethodDef( TexCoord4iv),
2136         MethodDef( TexCoord4s),
2137         MethodDef( TexCoord4sv),
2138         MethodDef( TexEnvf),
2139         MethodDef( TexEnvfv),
2140         MethodDef( TexEnvi),
2141         MethodDef( TexEnviv),
2142         MethodDef( TexGend),
2143         MethodDef( TexGendv),
2144         MethodDef( TexGenf),
2145         MethodDef( TexGenfv),
2146         MethodDef( TexGeni),
2147         MethodDef( TexGeniv),
2148         MethodDef( TexImage1D),
2149         MethodDef( TexImage2D),
2150         MethodDef( TexParameterf),
2151         MethodDef( TexParameterfv),
2152         MethodDef( TexParameteri),
2153         MethodDef( TexParameteriv),
2154         MethodDef( Translated),
2155         MethodDef( Translatef),
2156         MethodDef( Vertex2d),
2157         MethodDef( Vertex2dv),
2158         MethodDef( Vertex2f),
2159         MethodDef( Vertex2fv),
2160         MethodDef( Vertex2i),
2161         MethodDef( Vertex2iv),
2162         MethodDef( Vertex2s),
2163         MethodDef( Vertex2sv),
2164         MethodDef( Vertex3d),
2165         MethodDef( Vertex3dv),
2166         MethodDef( Vertex3f),
2167         MethodDef( Vertex3fv),
2168         MethodDef( Vertex3i),
2169         MethodDef( Vertex3iv),
2170         MethodDef( Vertex3s),
2171         MethodDef( Vertex3sv),
2172         MethodDef( Vertex4d),
2173         MethodDef( Vertex4dv),
2174         MethodDef( Vertex4f),
2175         MethodDef( Vertex4fv),
2176         MethodDef( Vertex4i),
2177         MethodDef( Vertex4iv),
2178         MethodDef( Vertex4s),
2179         MethodDef( Vertex4sv),
2180         MethodDef( Viewport),
2181 #endif
2182
2183         {NULL, NULL}
2184 };
2185
2186 PyObject *init_py_bgl(void) 
2187 {
2188         PyObject *mod= Py_InitModule(SUBMODULE(BGL), BGL_methods);
2189         PyObject *dict= PyModule_GetDict(mod);
2190
2191         Buffer_Type.ob_type= &PyType_Type;
2192         
2193         BPY_ADDCONST(dict, GL_CURRENT_BIT);
2194         BPY_ADDCONST(dict, GL_POINT_BIT);
2195         BPY_ADDCONST(dict, GL_LINE_BIT);
2196         BPY_ADDCONST(dict, GL_POLYGON_BIT);
2197         BPY_ADDCONST(dict, GL_POLYGON_STIPPLE_BIT);
2198         BPY_ADDCONST(dict, GL_PIXEL_MODE_BIT);
2199         BPY_ADDCONST(dict, GL_LIGHTING_BIT);
2200         BPY_ADDCONST(dict, GL_FOG_BIT);
2201         BPY_ADDCONST(dict, GL_DEPTH_BUFFER_BIT);
2202         BPY_ADDCONST(dict, GL_ACCUM_BUFFER_BIT);
2203         BPY_ADDCONST(dict, GL_STENCIL_BUFFER_BIT);
2204         BPY_ADDCONST(dict, GL_VIEWPORT_BIT);
2205         BPY_ADDCONST(dict, GL_TRANSFORM_BIT);
2206         BPY_ADDCONST(dict, GL_ENABLE_BIT);
2207         BPY_ADDCONST(dict, GL_COLOR_BUFFER_BIT);
2208         BPY_ADDCONST(dict, GL_HINT_BIT);
2209         BPY_ADDCONST(dict, GL_EVAL_BIT);
2210         BPY_ADDCONST(dict, GL_LIST_BIT);
2211         BPY_ADDCONST(dict, GL_TEXTURE_BIT);
2212         BPY_ADDCONST(dict, GL_SCISSOR_BIT);
2213         BPY_ADDCONST(dict, GL_ALL_ATTRIB_BITS);
2214
2215         BPY_ADDCONST(dict, GL_FALSE);
2216         BPY_ADDCONST(dict, GL_TRUE);
2217
2218         BPY_ADDCONST(dict, GL_POINTS);
2219         BPY_ADDCONST(dict, GL_LINES);
2220         BPY_ADDCONST(dict, GL_LINE_LOOP);
2221         BPY_ADDCONST(dict, GL_LINE_STRIP);
2222         BPY_ADDCONST(dict, GL_TRIANGLES);
2223         BPY_ADDCONST(dict, GL_TRIANGLE_STRIP);
2224         BPY_ADDCONST(dict, GL_TRIANGLE_FAN);
2225         BPY_ADDCONST(dict, GL_QUADS);
2226         BPY_ADDCONST(dict, GL_QUAD_STRIP);
2227         BPY_ADDCONST(dict, GL_POLYGON);
2228
2229         BPY_ADDCONST(dict, GL_ACCUM);
2230         BPY_ADDCONST(dict, GL_LOAD);
2231         BPY_ADDCONST(dict, GL_RETURN);
2232         BPY_ADDCONST(dict, GL_MULT);
2233         BPY_ADDCONST(dict, GL_ADD);
2234
2235         BPY_ADDCONST(dict, GL_NEVER);
2236         BPY_ADDCONST(dict, GL_LESS);
2237         BPY_ADDCONST(dict, GL_EQUAL);
2238         BPY_ADDCONST(dict, GL_LEQUAL);
2239         BPY_ADDCONST(dict, GL_GREATER);
2240         BPY_ADDCONST(dict, GL_NOTEQUAL);
2241         BPY_ADDCONST(dict, GL_GEQUAL);
2242         BPY_ADDCONST(dict, GL_ALWAYS);
2243
2244         BPY_ADDCONST(dict, GL_ZERO);
2245         BPY_ADDCONST(dict, GL_ONE);
2246         BPY_ADDCONST(dict, GL_SRC_COLOR);
2247         BPY_ADDCONST(dict, GL_ONE_MINUS_SRC_COLOR);
2248         BPY_ADDCONST(dict, GL_SRC_ALPHA);
2249         BPY_ADDCONST(dict, GL_ONE_MINUS_SRC_ALPHA);
2250         BPY_ADDCONST(dict, GL_DST_ALPHA);
2251         BPY_ADDCONST(dict, GL_ONE_MINUS_DST_ALPHA);
2252
2253         BPY_ADDCONST(dict, GL_DST_COLOR);
2254         BPY_ADDCONST(dict, GL_ONE_MINUS_DST_COLOR);
2255         BPY_ADDCONST(dict, GL_SRC_ALPHA_SATURATE);
2256
2257         BPY_ADDCONST(dict, GL_NONE);
2258         BPY_ADDCONST(dict, GL_FRONT_LEFT);
2259         BPY_ADDCONST(dict, GL_FRONT_RIGHT);
2260         BPY_ADDCONST(dict, GL_BACK_LEFT);
2261         BPY_ADDCONST(dict, GL_BACK_RIGHT);
2262         BPY_ADDCONST(dict, GL_FRONT);
2263         BPY_ADDCONST(dict, GL_BACK);
2264         BPY_ADDCONST(dict, GL_LEFT);
2265         BPY_ADDCONST(dict, GL_RIGHT);
2266         BPY_ADDCONST(dict, GL_FRONT_AND_BACK);
2267         BPY_ADDCONST(dict, GL_AUX0);
2268         BPY_ADDCONST(dict, GL_AUX1);
2269         BPY_ADDCONST(dict, GL_AUX2);
2270         BPY_ADDCONST(dict, GL_AUX3);
2271
2272         BPY_ADDCONST(dict, GL_NO_ERROR);
2273         BPY_ADDCONST(dict, GL_INVALID_ENUM);
2274         BPY_ADDCONST(dict, GL_INVALID_VALUE);
2275         BPY_ADDCONST(dict, GL_INVALID_OPERATION);
2276         BPY_ADDCONST(dict, GL_STACK_OVERFLOW);
2277         BPY_ADDCONST(dict, GL_STACK_UNDERFLOW);
2278         BPY_ADDCONST(dict, GL_OUT_OF_MEMORY);
2279
2280         BPY_ADDCONST(dict, GL_2D);
2281         BPY_ADDCONST(dict, GL_3D);
2282         BPY_ADDCONST(dict, GL_3D_COLOR);
2283         BPY_ADDCONST(dict, GL_3D_COLOR_TEXTURE);
2284         BPY_ADDCONST(dict, GL_4D_COLOR_TEXTURE);
2285
2286         BPY_ADDCONST(dict, GL_PASS_THROUGH_TOKEN);
2287         BPY_ADDCONST(dict, GL_POINT_TOKEN);
2288         BPY_ADDCONST(dict, GL_LINE_TOKEN);
2289         BPY_ADDCONST(dict, GL_POLYGON_TOKEN);
2290         BPY_ADDCONST(dict, GL_BITMAP_TOKEN);
2291         BPY_ADDCONST(dict, GL_DRAW_PIXEL_TOKEN);
2292         BPY_ADDCONST(dict, GL_COPY_PIXEL_TOKEN);
2293         BPY_ADDCONST(dict, GL_LINE_RESET_TOKEN);
2294
2295         BPY_ADDCONST(dict, GL_EXP);
2296         BPY_ADDCONST(dict, GL_EXP2);
2297
2298         BPY_ADDCONST(dict, GL_CW);
2299         BPY_ADDCONST(dict, GL_CCW);
2300
2301         BPY_ADDCONST(dict, GL_COEFF);
2302         BPY_ADDCONST(dict, GL_ORDER);
2303         BPY_ADDCONST(dict, GL_DOMAIN);
2304
2305         BPY_ADDCONST(dict, GL_PIXEL_MAP_I_TO_I);
2306         BPY_ADDCONST(dict, GL_PIXEL_MAP_S_TO_S);
2307         BPY_ADDCONST(dict, GL_PIXEL_MAP_I_TO_R);
2308         BPY_ADDCONST(dict, GL_PIXEL_MAP_I_TO_G);
2309         BPY_ADDCONST(dict, GL_PIXEL_MAP_I_TO_B);
2310         BPY_ADDCONST(dict, GL_PIXEL_MAP_I_TO_A);
2311         BPY_ADDCONST(dict, GL_PIXEL_MAP_R_TO_R);
2312         BPY_ADDCONST(dict, GL_PIXEL_MAP_G_TO_G);
2313         BPY_ADDCONST(dict, GL_PIXEL_MAP_B_TO_B);
2314         BPY_ADDCONST(dict, GL_PIXEL_MAP_A_TO_A);
2315
2316         BPY_ADDCONST(dict, GL_CURRENT_COLOR);
2317         BPY_ADDCONST(dict, GL_CURRENT_INDEX);
2318         BPY_ADDCONST(dict, GL_CURRENT_NORMAL);
2319         BPY_ADDCONST(dict, GL_CURRENT_TEXTURE_COORDS);
2320         BPY_ADDCONST(dict, GL_CURRENT_RASTER_COLOR);
2321         BPY_ADDCONST(dict, GL_CURRENT_RASTER_INDEX);
2322         BPY_ADDCONST(dict, GL_CURRENT_RASTER_TEXTURE_COORDS);
2323         BPY_ADDCONST(dict, GL_CURRENT_RASTER_POSITION);
2324         BPY_ADDCONST(dict, GL_CURRENT_RASTER_POSITION_VALID);
2325         BPY_ADDCONST(dict, GL_CURRENT_RASTER_DISTANCE);
2326         BPY_ADDCONST(dict, GL_POINT_SMOOTH);
2327         BPY_ADDCONST(dict, GL_POINT_SIZE);
2328         BPY_ADDCONST(dict, GL_POINT_SIZE_RANGE);
2329         BPY_ADDCONST(dict, GL_POINT_SIZE_GRANULARITY);
2330         BPY_ADDCONST(dict, GL_LINE_SMOOTH);
2331         BPY_ADDCONST(dict, GL_LINE_WIDTH);
2332         BPY_ADDCONST(dict, GL_LINE_WIDTH_RANGE);
2333         BPY_ADDCONST(dict, GL_LINE_WIDTH_GRANULARITY);
2334         BPY_ADDCONST(dict, GL_LINE_STIPPLE);
2335         BPY_ADDCONST(dict, GL_LINE_STIPPLE_PATTERN);
2336         BPY_ADDCONST(dict, GL_LINE_STIPPLE_REPEAT);
2337         BPY_ADDCONST(dict, GL_LIST_MODE);
2338         BPY_ADDCONST(dict, GL_MAX_LIST_NESTING);
2339         BPY_ADDCONST(dict, GL_LIST_BASE);
2340         BPY_ADDCONST(dict, GL_LIST_INDEX);
2341         BPY_ADDCONST(dict, GL_POLYGON_MODE);
2342         BPY_ADDCONST(dict, GL_POLYGON_SMOOTH);
2343         BPY_ADDCONST(dict, GL_POLYGON_STIPPLE);
2344         BPY_ADDCONST(dict, GL_EDGE_FLAG);
2345         BPY_ADDCONST(dict, GL_CULL_FACE);
2346         BPY_ADDCONST(dict, GL_CULL_FACE_MODE);
2347         BPY_ADDCONST(dict, GL_FRONT_FACE);
2348         BPY_ADDCONST(dict, GL_LIGHTING);
2349         BPY_ADDCONST(dict, GL_LIGHT_MODEL_LOCAL_VIEWER);
2350         BPY_ADDCONST(dict, GL_LIGHT_MODEL_TWO_SIDE);
2351         BPY_ADDCONST(dict, GL_LIGHT_MODEL_AMBIENT);
2352         BPY_ADDCONST(dict, GL_SHADE_MODEL);
2353         BPY_ADDCONST(dict, GL_COLOR_MATERIAL_FACE);
2354         BPY_ADDCONST(dict, GL_COLOR_MATERIAL_PARAMETER);
2355         BPY_ADDCONST(dict, GL_COLOR_MATERIAL);
2356         BPY_ADDCONST(dict, GL_FOG);
2357         BPY_ADDCONST(dict, GL_FOG_INDEX);
2358         BPY_ADDCONST(dict, GL_FOG_DENSITY);
2359         BPY_ADDCONST(dict, GL_FOG_START);
2360         BPY_ADDCONST(dict, GL_FOG_END);
2361         BPY_ADDCONST(dict, GL_FOG_MODE);
2362         BPY_ADDCONST(dict, GL_FOG_COLOR);
2363         BPY_ADDCONST(dict, GL_DEPTH_RANGE);
2364         BPY_ADDCONST(dict, GL_DEPTH_TEST);
2365         BPY_ADDCONST(dict, GL_DEPTH_WRITEMASK);
2366         BPY_ADDCONST(dict, GL_DEPTH_CLEAR_VALUE);
2367         BPY_ADDCONST(dict, GL_DEPTH_FUNC);
2368         BPY_ADDCONST(dict, GL_ACCUM_CLEAR_VALUE);
2369         BPY_ADDCONST(dict, GL_STENCIL_TEST);
2370         BPY_ADDCONST(dict, GL_STENCIL_CLEAR_VALUE);
2371         BPY_ADDCONST(dict, GL_STENCIL_FUNC);
2372         BPY_ADDCONST(dict, GL_STENCIL_VALUE_MASK);
2373         BPY_ADDCONST(dict, GL_STENCIL_FAIL);
2374         BPY_ADDCONST(dict, GL_STENCIL_PASS_DEPTH_FAIL);
2375         BPY_ADDCONST(dict, GL_STENCIL_PASS_DEPTH_PASS);
2376         BPY_ADDCONST(dict, GL_STENCIL_REF);
2377         BPY_ADDCONST(dict, GL_STENCIL_WRITEMASK);
2378         BPY_ADDCONST(dict, GL_MATRIX_MODE);
2379         BPY_ADDCONST(dict, GL_NORMALIZE);
2380         BPY_ADDCONST(dict, GL_VIEWPORT);
2381         BPY_ADDCONST(dict, GL_MODELVIEW_STACK_DEPTH);
2382         BPY_ADDCONST(dict, GL_PROJECTION_STACK_DEPTH);
2383         BPY_ADDCONST(dict, GL_TEXTURE_STACK_DEPTH);
2384         BPY_ADDCONST(dict, GL_MODELVIEW_MATRIX);
2385         BPY_ADDCONST(dict, GL_PROJECTION_MATRIX);
2386         BPY_ADDCONST(dict, GL_TEXTURE_MATRIX);
2387         BPY_ADDCONST(dict, GL_ATTRIB_STACK_DEPTH);
2388         BPY_ADDCONST(dict, GL_ALPHA_TEST);
2389         BPY_ADDCONST(dict, GL_ALPHA_TEST_FUNC);
2390         BPY_ADDCONST(dict, GL_ALPHA_TEST_REF);
2391         BPY_ADDCONST(dict, GL_DITHER);
2392         BPY_ADDCONST(dict, GL_BLEND_DST);
2393         BPY_ADDCONST(dict, GL_BLEND_SRC);
2394         BPY_ADDCONST(dict, GL_BLEND);
2395         BPY_ADDCONST(dict, GL_LOGIC_OP_MODE);
2396         BPY_ADDCONST(dict, GL_LOGIC_OP);
2397         BPY_ADDCONST(dict, GL_AUX_BUFFERS);
2398         BPY_ADDCONST(dict, GL_DRAW_BUFFER);
2399         BPY_ADDCONST(dict, GL_READ_BUFFER);
2400         BPY_ADDCONST(dict, GL_SCISSOR_BOX);
2401         BPY_ADDCONST(dict, GL_SCISSOR_TEST);
2402         BPY_ADDCONST(dict, GL_INDEX_CLEAR_VALUE);
2403         BPY_ADDCONST(dict, GL_INDEX_WRITEMASK);
2404         BPY_ADDCONST(dict, GL_COLOR_CLEAR_VALUE);
2405         BPY_ADDCONST(dict, GL_COLOR_WRITEMASK);
2406         BPY_ADDCONST(dict, GL_INDEX_MODE);
2407         BPY_ADDCONST(dict, GL_RGBA_MODE);
2408         BPY_ADDCONST(dict, GL_DOUBLEBUFFER);
2409         BPY_ADDCONST(dict, GL_STEREO);
2410         BPY_ADDCONST(dict, GL_RENDER_MODE);
2411         BPY_ADDCONST(dict, GL_PERSPECTIVE_CORRECTION_HINT);
2412         BPY_ADDCONST(dict, GL_POINT_SMOOTH_HINT);
2413         BPY_ADDCONST(dict, GL_LINE_SMOOTH_HINT);
2414         BPY_ADDCONST(dict, GL_POLYGON_SMOOTH_HINT);
2415         BPY_ADDCONST(dict, GL_FOG_HINT);
2416         BPY_ADDCONST(dict, GL_TEXTURE_GEN_S);
2417         BPY_ADDCONST(dict, GL_TEXTURE_GEN_T);
2418         BPY_ADDCONST(dict, GL_TEXTURE_GEN_R);
2419         BPY_ADDCONST(dict, GL_TEXTURE_GEN_Q);
2420         BPY_ADDCONST(dict, GL_PIXEL_MAP_I_TO_I_SIZE);
2421         BPY_ADDCONST(dict, GL_PIXEL_MAP_S_TO_S_SIZE);
2422         BPY_ADDCONST(dict, GL_PIXEL_MAP_I_TO_R_SIZE);
2423         BPY_ADDCONST(dict, GL_PIXEL_MAP_I_TO_G_SIZE);
2424         BPY_ADDCONST(dict, GL_PIXEL_MAP_I_TO_B_SIZE);
2425         BPY_ADDCONST(dict, GL_PIXEL_MAP_I_TO_A_SIZE);
2426         BPY_ADDCONST(dict, GL_PIXEL_MAP_R_TO_R_SIZE);
2427         BPY_ADDCONST(dict, GL_PIXEL_MAP_G_TO_G_SIZE);
2428         BPY_ADDCONST(dict, GL_PIXEL_MAP_B_TO_B_SIZE);
2429         BPY_ADDCONST(dict, GL_PIXEL_MAP_A_TO_A_SIZE);
2430         BPY_ADDCONST(dict, GL_UNPACK_SWAP_BYTES);
2431         BPY_ADDCONST(dict, GL_UNPACK_LSB_FIRST);
2432         BPY_ADDCONST(dict, GL_UNPACK_ROW_LENGTH);
2433         BPY_ADDCONST(dict, GL_UNPACK_SKIP_ROWS);
2434         BPY_ADDCONST(dict, GL_UNPACK_SKIP_PIXELS);
2435         BPY_ADDCONST(dict, GL_UNPACK_ALIGNMENT);
2436         BPY_ADDCONST(dict, GL_PACK_SWAP_BYTES);
2437         BPY_ADDCONST(dict, GL_PACK_LSB_FIRST);
2438         BPY_ADDCONST(dict, GL_PACK_ROW_LENGTH);
2439         BPY_ADDCONST(dict, GL_PACK_SKIP_ROWS);
2440         BPY_ADDCONST(dict, GL_PACK_SKIP_PIXELS);
2441         BPY_ADDCONST(dict, GL_PACK_ALIGNMENT);
2442         BPY_ADDCONST(dict, GL_MAP_COLOR);
2443         BPY_ADDCONST(dict, GL_MAP_STENCIL);
2444         BPY_ADDCONST(dict, GL_INDEX_SHIFT);
2445         BPY_ADDCONST(dict, GL_INDEX_OFFSET);
2446         BPY_ADDCONST(dict, GL_RED_SCALE);
2447         BPY_ADDCONST(dict, GL_RED_BIAS);
2448         BPY_ADDCONST(dict, GL_ZOOM_X);
2449         BPY_ADDCONST(dict, GL_ZOOM_Y);
2450         BPY_ADDCONST(dict, GL_GREEN_SCALE);
2451         BPY_ADDCONST(dict, GL_GREEN_BIAS);
2452         BPY_ADDCONST(dict, GL_BLUE_SCALE);
2453         BPY_ADDCONST(dict, GL_BLUE_BIAS);
2454         BPY_ADDCONST(dict, GL_ALPHA_SCALE);
2455         BPY_ADDCONST(dict, GL_ALPHA_BIAS);
2456         BPY_ADDCONST(dict, GL_DEPTH_SCALE);
2457         BPY_ADDCONST(dict, GL_DEPTH_BIAS);
2458         BPY_ADDCONST(dict, GL_MAX_EVAL_ORDER);
2459         BPY_ADDCONST(dict, GL_MAX_LIGHTS);
2460         BPY_ADDCONST(dict, GL_MAX_CLIP_PLANES);
2461         BPY_ADDCONST(dict, GL_MAX_TEXTURE_SIZE);
2462         BPY_ADDCONST(dict, GL_MAX_PIXEL_MAP_TABLE);
2463         BPY_ADDCONST(dict, GL_MAX_ATTRIB_STACK_DEPTH);
2464         BPY_ADDCONST(dict, GL_MAX_MODELVIEW_STACK_DEPTH);
2465         BPY_ADDCONST(dict, GL_MAX_NAME_STACK_DEPTH);
2466         BPY_ADDCONST(dict, GL_MAX_PROJECTION_STACK_DEPTH);
2467         BPY_ADDCONST(dict, GL_MAX_TEXTURE_STACK_DEPTH);
2468         BPY_ADDCONST(dict, GL_MAX_VIEWPORT_DIMS);
2469         BPY_ADDCONST(dict, GL_SUBPIXEL_BITS);
2470         BPY_ADDCONST(dict, GL_INDEX_BITS);
2471         BPY_ADDCONST(dict, GL_RED_BITS);
2472         BPY_ADDCONST(dict, GL_GREEN_BITS);
2473         BPY_ADDCONST(dict, GL_BLUE_BITS);
2474         BPY_ADDCONST(dict, GL_ALPHA_BITS);
2475         BPY_ADDCONST(dict, GL_DEPTH_BITS);
2476         BPY_ADDCONST(dict, GL_STENCIL_BITS);
2477         BPY_ADDCONST(dict, GL_ACCUM_RED_BITS);
2478         BPY_ADDCONST(dict, GL_ACCUM_GREEN_BITS);
2479         BPY_ADDCONST(dict, GL_ACCUM_BLUE_BITS);
2480         BPY_ADDCONST(dict, GL_ACCUM_ALPHA_BITS);
2481         BPY_ADDCONST(dict, GL_NAME_STACK_DEPTH);
2482         BPY_ADDCONST(dict, GL_AUTO_NORMAL);
2483         BPY_ADDCONST(dict, GL_MAP1_COLOR_4);
2484         BPY_ADDCONST(dict, GL_MAP1_INDEX);
2485         BPY_ADDCONST(dict, GL_MAP1_NORMAL);
2486         BPY_ADDCONST(dict, GL_MAP1_TEXTURE_COORD_1);
2487         BPY_ADDCONST(dict, GL_MAP1_TEXTURE_COORD_2);
2488         BPY_ADDCONST(dict, GL_MAP1_TEXTURE_COORD_3);
2489         BPY_ADDCONST(dict, GL_MAP1_TEXTURE_COORD_4);
2490         BPY_ADDCONST(dict, GL_MAP1_VERTEX_3);
2491         BPY_ADDCONST(dict, GL_MAP1_VERTEX_4);
2492         BPY_ADDCONST(dict, GL_MAP2_COLOR_4);
2493         BPY_ADDCONST(dict, GL_MAP2_INDEX);
2494         BPY_ADDCONST(dict, GL_MAP2_NORMAL);
2495         BPY_ADDCONST(dict, GL_MAP2_TEXTURE_COORD_1);
2496         BPY_ADDCONST(dict, GL_MAP2_TEXTURE_COORD_2);
2497         BPY_ADDCONST(dict, GL_MAP2_TEXTURE_COORD_3);
2498         BPY_ADDCONST(dict, GL_MAP2_TEXTURE_COORD_4);
2499         BPY_ADDCONST(dict, GL_MAP2_VERTEX_3);
2500         BPY_ADDCONST(dict, GL_MAP2_VERTEX_4);
2501         BPY_ADDCONST(dict, GL_MAP1_GRID_DOMAIN);
2502         BPY_ADDCONST(dict, GL_MAP1_GRID_SEGMENTS);
2503         BPY_ADDCONST(dict, GL_MAP2_GRID_DOMAIN);
2504         BPY_ADDCONST(dict, GL_MAP2_GRID_SEGMENTS);
2505         BPY_ADDCONST(dict, GL_TEXTURE_1D);
2506         BPY_ADDCONST(dict, GL_TEXTURE_2D);
2507
2508         BPY_ADDCONST(dict, GL_TEXTURE_WIDTH);
2509         BPY_ADDCONST(dict, GL_TEXTURE_HEIGHT);
2510         BPY_ADDCONST(dict, GL_TEXTURE_COMPONENTS);
2511         BPY_ADDCONST(dict, GL_TEXTURE_BORDER_COLOR);
2512         BPY_ADDCONST(dict, GL_TEXTURE_BORDER);
2513
2514         BPY_ADDCONST(dict, GL_DONT_CARE);
2515         BPY_ADDCONST(dict, GL_FASTEST);
2516         BPY_ADDCONST(dict, GL_NICEST);
2517
2518         BPY_ADDCONST(dict, GL_AMBIENT);
2519         BPY_ADDCONST(dict, GL_DIFFUSE);
2520         BPY_ADDCONST(dict, GL_SPECULAR);
2521         BPY_ADDCONST(dict, GL_POSITION);
2522         BPY_ADDCONST(dict, GL_SPOT_DIRECTION);
2523         BPY_ADDCONST(dict, GL_SPOT_EXPONENT);
2524         BPY_ADDCONST(dict, GL_SPOT_CUTOFF);
2525         BPY_ADDCONST(dict, GL_CONSTANT_ATTENUATION);
2526         BPY_ADDCONST(dict, GL_LINEAR_ATTENUATION);
2527         BPY_ADDCONST(dict, GL_QUADRATIC_ATTENUATION);
2528
2529         BPY_ADDCONST(dict, GL_COMPILE);
2530         BPY_ADDCONST(dict, GL_COMPILE_AND_EXECUTE);
2531
2532         BPY_ADDCONST(dict, GL_BYTE);
2533         BPY_ADDCONST(dict, GL_UNSIGNED_BYTE);
2534         BPY_ADDCONST(dict, GL_SHORT);
2535         BPY_ADDCONST(dict, GL_UNSIGNED_SHORT);
2536         BPY_ADDCONST(dict, GL_INT);
2537         BPY_ADDCONST(dict, GL_UNSIGNED_INT);
2538         BPY_ADDCONST(dict, GL_FLOAT);
2539         BPY_ADDCONST(dict, GL_2_BYTES);
2540         BPY_ADDCONST(dict, GL_3_BYTES);
2541         BPY_ADDCONST(dict, GL_4_BYTES);
2542
2543         BPY_ADDCONST(dict, GL_CLEAR);
2544         BPY_ADDCONST(dict, GL_AND);
2545         BPY_ADDCONST(dict, GL_AND_REVERSE);
2546         BPY_ADDCONST(dict, GL_COPY);
2547         BPY_ADDCONST(dict, GL_AND_INVERTED);
2548         BPY_ADDCONST(dict, GL_NOOP);
2549         BPY_ADDCONST(dict, GL_XOR);
2550         BPY_ADDCONST(dict, GL_OR);
2551         BPY_ADDCONST(dict, GL_NOR);
2552         BPY_ADDCONST(dict, GL_EQUIV);
2553         BPY_ADDCONST(dict, GL_INVERT);
2554         BPY_ADDCONST(dict, GL_OR_REVERSE);
2555         BPY_ADDCONST(dict, GL_COPY_INVERTED);
2556         BPY_ADDCONST(dict, GL_OR_INVERTED);
2557         BPY_ADDCONST(dict, GL_NAND);
2558         BPY_ADDCONST(dict, GL_SET);
2559
2560         BPY_ADDCONST(dict, GL_EMISSION);
2561         BPY_ADDCONST(dict, GL_SHININESS);
2562         BPY_ADDCONST(dict, GL_AMBIENT_AND_DIFFUSE);
2563         BPY_ADDCONST(dict, GL_COLOR_INDEXES);
2564
2565         BPY_ADDCONST(dict, GL_MODELVIEW);
2566         BPY_ADDCONST(dict, GL_PROJECTION);
2567         BPY_ADDCONST(dict, GL_TEXTURE);
2568
2569         BPY_ADDCONST(dict, GL_COLOR);
2570         BPY_ADDCONST(dict, GL_DEPTH);
2571         BPY_ADDCONST(dict, GL_STENCIL);
2572
2573         BPY_ADDCONST(dict, GL_COLOR_INDEX);
2574         BPY_ADDCONST(dict, GL_STENCIL_INDEX);
2575         BPY_ADDCONST(dict, GL_DEPTH_COMPONENT);
2576         BPY_ADDCONST(dict, GL_RED);
2577         BPY_ADDCONST(dict, GL_GREEN);
2578         BPY_ADDCONST(dict, GL_BLUE);
2579         BPY_ADDCONST(dict, GL_ALPHA);
2580         BPY_ADDCONST(dict, GL_RGB);
2581         BPY_ADDCONST(dict, GL_RGBA);
2582         BPY_ADDCONST(dict, GL_LUMINANCE);
2583         BPY_ADDCONST(dict, GL_LUMINANCE_ALPHA);
2584
2585         BPY_ADDCONST(dict, GL_BITMAP);
2586
2587         BPY_ADDCONST(dict, GL_POINT);
2588         BPY_ADDCONST(dict, GL_LINE);
2589         BPY_ADDCONST(dict, GL_FILL);
2590
2591         BPY_ADDCONST(dict, GL_RENDER);
2592         BPY_ADDCONST(dict, GL_FEEDBACK);
2593         BPY_ADDCONST(dict, GL_SELECT);
2594
2595         BPY_ADDCONST(dict, GL_FLAT);
2596         BPY_ADDCONST(dict, GL_SMOOTH);
2597
2598         BPY_ADDCONST(dict, GL_KEEP);
2599         BPY_ADDCONST(dict, GL_REPLACE);
2600         BPY_ADDCONST(dict, GL_INCR);
2601         BPY_ADDCONST(dict, GL_DECR);
2602
2603         BPY_ADDCONST(dict, GL_VENDOR);
2604         BPY_ADDCONST(dict, GL_RENDERER);
2605         BPY_ADDCONST(dict, GL_VERSION);
2606         BPY_ADDCONST(dict, GL_EXTENSIONS);
2607
2608         BPY_ADDCONST(dict, GL_S);
2609         BPY_ADDCONST(dict, GL_T);
2610         BPY_ADDCONST(dict, GL_R);
2611         BPY_ADDCONST(dict, GL_Q);
2612
2613         BPY_ADDCONST(dict, GL_MODULATE);
2614         BPY_ADDCONST(dict, GL_DECAL);
2615
2616         BPY_ADDCONST(dict, GL_TEXTURE_ENV_MODE);
2617         BPY_ADDCONST(dict, GL_TEXTURE_ENV_COLOR);
2618
2619         BPY_ADDCONST(dict, GL_TEXTURE_ENV);
2620
2621         BPY_ADDCONST(dict, GL_EYE_LINEAR);
2622         BPY_ADDCONST(dict, GL_OBJECT_LINEAR);
2623         BPY_ADDCONST(dict, GL_SPHERE_MAP);
2624
2625         BPY_ADDCONST(dict, GL_TEXTURE_GEN_MODE);
2626         BPY_ADDCONST(dict, GL_OBJECT_PLANE);
2627         BPY_ADDCONST(dict, GL_EYE_PLANE);
2628
2629         BPY_ADDCONST(dict, GL_NEAREST);
2630         BPY_ADDCONST(dict, GL_LINEAR);
2631
2632         BPY_ADDCONST(dict, GL_NEAREST_MIPMAP_NEAREST);
2633         BPY_ADDCONST(dict, GL_LINEAR_MIPMAP_NEAREST);
2634         BPY_ADDCONST(dict, GL_NEAREST_MIPMAP_LINEAR);
2635         BPY_ADDCONST(dict, GL_LINEAR_MIPMAP_LINEAR);
2636
2637         BPY_ADDCONST(dict, GL_TEXTURE_MAG_FILTER);
2638         BPY_ADDCONST(dict, GL_TEXTURE_MIN_FILTER);
2639         BPY_ADDCONST(dict, GL_TEXTURE_WRAP_S);
2640         BPY_ADDCONST(dict, GL_TEXTURE_WRAP_T);
2641
2642         BPY_ADDCONST(dict, GL_CLAMP);
2643         BPY_ADDCONST(dict, GL_REPEAT);
2644
2645         BPY_ADDCONST(dict, GL_CLIP_PLANE0);
2646         BPY_ADDCONST(dict, GL_CLIP_PLANE1);
2647         BPY_ADDCONST(dict, GL_CLIP_PLANE2);
2648         BPY_ADDCONST(dict, GL_CLIP_PLANE3);
2649         BPY_ADDCONST(dict, GL_CLIP_PLANE4);
2650         BPY_ADDCONST(dict, GL_CLIP_PLANE5);
2651
2652         BPY_ADDCONST(dict, GL_LIGHT0);
2653         BPY_ADDCONST(dict, GL_LIGHT1);
2654         BPY_ADDCONST(dict, GL_LIGHT2);
2655         BPY_ADDCONST(dict, GL_LIGHT3);
2656         BPY_ADDCONST(dict, GL_LIGHT4);
2657         BPY_ADDCONST(dict, GL_LIGHT5);
2658         BPY_ADDCONST(dict, GL_LIGHT6);
2659         BPY_ADDCONST(dict, GL_LIGHT7);
2660         
2661         BPY_ADDCONST(dict, GL_POLYGON_OFFSET_UNITS);
2662         BPY_ADDCONST(dict, GL_POLYGON_OFFSET_POINT);
2663         BPY_ADDCONST(dict, GL_POLYGON_OFFSET_LINE);
2664         BPY_ADDCONST(dict, GL_POLYGON_OFFSET_FILL);
2665         BPY_ADDCONST(dict, GL_POLYGON_OFFSET_FACTOR);
2666         
2667         BPY_ADDCONST(dict, GL_TEXTURE_PRIORITY);
2668         BPY_ADDCONST(dict, GL_TEXTURE_RESIDENT);
2669         BPY_ADDCONST(dict, GL_TEXTURE_BINDING_1D);
2670         BPY_ADDCONST(dict, GL_TEXTURE_BINDING_2D);
2671                         
2672         return mod;
2673 }
2674
2675 void initDraw(void) 
2676 {
2677         init_py_draw();
2678         init_py_bgl();
2679 }