/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 1.3.13u-20020617-2210
 * 
 * This file is not intended to be easily readable and contains a number of 
 * coding conventions designed to improve portability and efficiency. Do not make
 * changes to this file unless you know what you are doing--modify the SWIG 
 * interface file instead. 
 * ----------------------------------------------------------------------------- */

#define SWIGPYTHON
/***********************************************************************
 * common.swg
 *
 *     This file contains generic SWIG runtime support for pointer
 *     type checking as well as a few commonly used macros to control
 *     external linkage.
 *
 * Author : David Beazley (beazley@cs.uchicago.edu)
 *
 * Copyright (c) 1999-2000, The University of Chicago
 * 
 * This file may be freely redistributed without license or fee provided
 * this copyright message remains intact.
 ************************************************************************/

#include <string.h>

#if defined(_WIN32) || defined(__WIN32__)
#       if defined(_MSC_VER)
#               if defined(STATIC_LINKED)
#                       define SWIGEXPORT(a) a
#                       define SWIGIMPORT(a) extern a
#               else
#                       define SWIGEXPORT(a) __declspec(dllexport) a
#                       define SWIGIMPORT(a) extern a
#               endif
#       else
#               if defined(__BORLANDC__)
#                       define SWIGEXPORT(a) a _export
#                       define SWIGIMPORT(a) a _export
#               else
#                       define SWIGEXPORT(a) a
#                       define SWIGIMPORT(a) a
#               endif
#       endif
#else
#       define SWIGEXPORT(a) a
#       define SWIGIMPORT(a) a
#endif

#ifdef SWIG_GLOBAL
#define SWIGRUNTIME(a) SWIGEXPORT(a)
#else
#define SWIGRUNTIME(a) static a
#endif

#ifdef __cplusplus
extern "C" {
#endif

typedef void *(*swig_converter_func)(void *);
typedef struct swig_type_info *(*swig_dycast_func)(void **);

typedef struct swig_type_info {
  const char             *name;                 
  swig_converter_func     converter;
  const char             *str;
  swig_dycast_func        dcast;
  struct swig_type_info  *next;
  struct swig_type_info  *prev;
  void                   *clientdata;	
} swig_type_info;

#ifdef SWIG_NOINCLUDE

SWIGIMPORT(swig_type_info *) SWIG_TypeRegister(swig_type_info *);
SWIGIMPORT(swig_type_info *) SWIG_TypeCheck(char *c, swig_type_info *);
SWIGIMPORT(void *)           SWIG_TypeCast(swig_type_info *, void *);
SWIGIMPORT(swig_type_info *) SWIG_TypeDynamicCast(swig_type_info *, void **);
SWIGIMPORT(swig_type_info *) SWIG_TypeQuery(const char *);
SWIGIMPORT(void)             SWIG_TypeClientData(swig_type_info *, void *);

#else

static swig_type_info *swig_type_list = 0;

/* Register a type mapping with the type-checking */
SWIGRUNTIME(swig_type_info *)
SWIG_TypeRegister(swig_type_info *ti)
{
  swig_type_info *tc, *head, *ret, *next;
  /* Check to see if this type has already been registered */
  tc = swig_type_list;
  while (tc) {
    if (strcmp(tc->name, ti->name) == 0) {
      /* Already exists in the table.  Just add additional types to the list */
      head = tc;
      next = tc->next;
      goto l1;
    }
    tc = tc->prev;
  }
  head = ti;
  next = 0;

  /* Place in list */
  ti->prev = swig_type_list;
  swig_type_list = ti;

  /* Build linked lists */
 l1:
  ret = head;
  tc = ti + 1;
  /* Patch up the rest of the links */
  while (tc->name) {
    head->next = tc;
    tc->prev = head;
    head = tc;
    tc++;
  }
  head->next = next;
  return ret;
}

/* Check the typename */
SWIGRUNTIME(swig_type_info *) 
SWIG_TypeCheck(char *c, swig_type_info *ty)
{
  swig_type_info *s;
  if (!ty) return 0;        /* Void pointer */
  s = ty->next;             /* First element always just a name */
  while (s) {
    if (strcmp(s->name,c) == 0) {
      if (s == ty->next) return s;
      /* Move s to the top of the linked list */
      s->prev->next = s->next;
      if (s->next) {
	s->next->prev = s->prev;
      }
      /* Insert s as second element in the list */
      s->next = ty->next;
      if (ty->next) ty->next->prev = s;
      ty->next = s;
      return s;
    }
    s = s->next;
  }
  return 0;
}

/* Cast a pointer up an inheritance hierarchy */
SWIGRUNTIME(void *) 
SWIG_TypeCast(swig_type_info *ty, void *ptr) 
{
  if ((!ty) || (!ty->converter)) return ptr;
  return (*ty->converter)(ptr);
}

/* Dynamic pointer casting. Down an inheritance hierarchy */
SWIGRUNTIME(swig_type_info *) 
SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) 
{
  swig_type_info *lastty = ty;
  if (!ty || !ty->dcast) return ty;
  while (ty && (ty->dcast)) {
     ty = (*ty->dcast)(ptr);
     if (ty) lastty = ty;
  }
  return lastty;
}

/* Search for a swig_type_info structure */
SWIGRUNTIME(swig_type_info *)
SWIG_TypeQuery(const char *name) {
  swig_type_info *ty = swig_type_list;
  while (ty) {
    if (ty->str && (strcmp(name,ty->str) == 0)) return ty;
    if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
    ty = ty->prev;
  }
  return 0;
}

/* Set the clientdata field for a type */
SWIGRUNTIME(void)
SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
  swig_type_info *tc, *equiv;
  if (ti->clientdata) return;
  ti->clientdata = clientdata;
  equiv = ti->next;
  while (equiv) {
    if (!equiv->converter) {
      tc = swig_type_list;
      while (tc) {
	if ((strcmp(tc->name, equiv->name) == 0))
	  SWIG_TypeClientData(tc,clientdata);
	tc = tc->prev;
      }
    }
    equiv = equiv->next;
  }
}
#endif

#ifdef __cplusplus
}

#endif

/***********************************************************************
 * python.swg
 *
 *     This file contains the runtime support for Python modules
 *     and includes code for managing global variables and pointer
 *     type checking.
 *
 * Author : David Beazley (beazley@cs.uchicago.edu)
 ************************************************************************/

#include <stdlib.h>
#include "Python.h"

#ifdef __cplusplus
extern "C" {
#endif

#define SWIG_PY_INT     1
#define SWIG_PY_FLOAT   2
#define SWIG_PY_STRING  3
#define SWIG_PY_POINTER 4
#define SWIG_PY_BINARY  5

/* Constant information structure */
typedef struct swig_const_info {
    int type;
    char *name;
    long lvalue;
    double dvalue;
    void   *pvalue;
    swig_type_info **ptype;
} swig_const_info;

#ifdef SWIG_NOINCLUDE

SWIGEXPORT(PyObject *)        SWIG_newvarlink();
SWIGEXPORT(void)              SWIG_addvarlink(PyObject *, char *, PyObject *(*)(void), int (*)(PyObject *));
SWIGEXPORT(int)               SWIG_ConvertPtr(PyObject *, void **, swig_type_info *, int);
SWIGEXPORT(int)               SWIG_ConvertPacked(PyObject *, void *, int sz, swig_type_info *, int);
SWIGEXPORT(char *)            SWIG_PackData(char *c, void *, int);
SWIGEXPORT(char *)            SWIG_UnpackData(char *c, void *, int);
SWIGEXPORT(PyObject *)        SWIG_NewPointerObj(void *, swig_type_info *,int own);
SWIGEXPORT(PyObject *)        SWIG_NewPackedObj(void *, int sz, swig_type_info *);
SWIGEXPORT(void)              SWIG_InstallConstants(PyObject *d, swig_const_info constants[]);
#else

/* -----------------------------------------------------------------------------
 * global variable support code.
 * ----------------------------------------------------------------------------- */

typedef struct swig_globalvar {   
  char       *name;                  /* Name of global variable */
  PyObject *(*get_attr)(void);       /* Return the current value */
  int       (*set_attr)(PyObject *); /* Set the value */
  struct swig_globalvar *next;
} swig_globalvar;

typedef struct swig_varlinkobject {
  PyObject_HEAD
  swig_globalvar *vars;
} swig_varlinkobject;

static PyObject *
swig_varlink_repr(swig_varlinkobject *v) {
  v = v;
  return PyString_FromString("<Global variables>");
}

static int
swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
  swig_globalvar  *var;
  flags = flags;
  fprintf(fp,"Global variables { ");
  for (var = v->vars; var; var=var->next) {
    fprintf(fp,"%s", var->name);
    if (var->next) fprintf(fp,", ");
  }
  fprintf(fp," }\n");
  return 0;
}

static PyObject *
swig_varlink_getattr(swig_varlinkobject *v, char *n) {
  swig_globalvar *var = v->vars;
  while (var) {
    if (strcmp(var->name,n) == 0) {
      return (*var->get_attr)();
    }
    var = var->next;
  }
  PyErr_SetString(PyExc_NameError,"Unknown C global variable");
  return NULL;
}

static int
swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
  swig_globalvar *var = v->vars;
  while (var) {
    if (strcmp(var->name,n) == 0) {
      return (*var->set_attr)(p);
    }
    var = var->next;
  }
  PyErr_SetString(PyExc_NameError,"Unknown C global variable");
  return 1;
}

statichere PyTypeObject varlinktype = {
  PyObject_HEAD_INIT(0)              
  0,
  (char *)"swigvarlink",                      /* Type name    */
  sizeof(swig_varlinkobject),         /* Basic size   */
  0,                                  /* Itemsize     */
  0,                                  /* Deallocator  */ 
  (printfunc) swig_varlink_print,     /* Print        */
  (getattrfunc) swig_varlink_getattr, /* get attr     */
  (setattrfunc) swig_varlink_setattr, /* Set attr     */
  0,                                  /* tp_compare   */
  (reprfunc) swig_varlink_repr,       /* tp_repr      */    
  0,                                  /* tp_as_number */
  0,                                  /* tp_as_mapping*/
  0,                                  /* tp_hash      */
};

/* Create a variable linking object for use later */
SWIGRUNTIME(PyObject *)
SWIG_newvarlink(void) {
  swig_varlinkobject *result = 0;
  result = PyMem_NEW(swig_varlinkobject,1);
  varlinktype.ob_type = &PyType_Type;    /* Patch varlinktype into a PyType */
  result->ob_type = &varlinktype;
  result->vars = 0;
  result->ob_refcnt = 0;
  Py_XINCREF((PyObject *) result);
  return ((PyObject*) result);
}

SWIGRUNTIME(void)
SWIG_addvarlink(PyObject *p, char *name,
	   PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
  swig_varlinkobject *v;
  swig_globalvar *gv;
  v= (swig_varlinkobject *) p;
  gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
  gv->name = (char *) malloc(strlen(name)+1);
  strcpy(gv->name,name);
  gv->get_attr = get_attr;
  gv->set_attr = set_attr;
  gv->next = v->vars;
  v->vars = gv;
}

/* Pack binary data into a string */
SWIGRUNTIME(char *)
SWIG_PackData(char *c, void *ptr, int sz) {
  static char hex[17] = "0123456789abcdef";
  int i;
  unsigned char *u = (unsigned char *) ptr;
  register unsigned char uu;
  for (i = 0; i < sz; i++,u++) {
    uu = *u;
    *(c++) = hex[(uu & 0xf0) >> 4];
    *(c++) = hex[uu & 0xf];
  }
  return c;
}

/* Unpack binary data from a string */
SWIGRUNTIME(char *)
SWIG_UnpackData(char *c, void *ptr, int sz) {
  register unsigned char uu = 0;
  register int d;
  unsigned char *u = (unsigned char *) ptr;
  int i;
  for (i = 0; i < sz; i++, u++) {
    d = *(c++);
    if ((d >= '0') && (d <= '9'))
      uu = ((d - '0') << 4);
    else if ((d >= 'a') && (d <= 'f'))
      uu = ((d - ('a'-10)) << 4);
    d = *(c++);
    if ((d >= '0') && (d <= '9'))
      uu |= (d - '0');
    else if ((d >= 'a') && (d <= 'f'))
      uu |= (d - ('a'-10));
    *u = uu;
  }
  return c;
}

/* Convert a pointer value */
SWIGRUNTIME(int)
SWIG_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
  swig_type_info *tc;
  char  *c;
  static PyObject *SWIG_this = 0;
  int    newref = 0;

  if (!obj) return 0;
  if (obj == Py_None) {
    *ptr = 0;
    return 0;
  }
#ifdef SWIG_COBJECT_TYPES
  if (!(PyCObject_Check(obj))) {
    if (!SWIG_this)
      SWIG_this = PyString_InternFromString("this");
    obj = PyObject_GetAttr(obj,SWIG_this);
    newref = 1;
    if (!obj) goto type_error;
    if (!PyCObject_Check(obj)) {
      Py_DECREF(obj);
      goto type_error;
    }
  } 
  *ptr = PyCObject_AsVoidPtr(obj);
  c = (char *) PyCObject_GetDesc(obj);
  if (newref) Py_DECREF(obj);
  goto cobject;
#else
  if (!(PyString_Check(obj))) {
    if (!SWIG_this)
      SWIG_this = PyString_InternFromString("this");
    obj = PyObject_GetAttr(obj,SWIG_this);
    newref = 1;
    if (!obj) goto type_error;
    if (!PyString_Check(obj)) {
      Py_DECREF(obj);
      goto type_error;
    }
  } 
  c = PyString_AsString(obj);
  /* Pointer values must start with leading underscore */
  if (*c != '_') {
    *ptr = (void *) 0;
    if (strcmp(c,"NULL") == 0) {
      if (newref) { Py_DECREF(obj); }
      return 0;
    } else {
      if (newref) { Py_DECREF(obj); }
      goto type_error;
    }
  }
  c++;
  c = SWIG_UnpackData(c,ptr,sizeof(void *));
  if (newref) { Py_DECREF(obj); }
#endif

#ifdef SWIG_COBJECT_TYPES
cobject:
#endif

  if (ty) {
    tc = SWIG_TypeCheck(c,ty);
    if (!tc) goto type_error;
    *ptr = SWIG_TypeCast(tc,(void*) *ptr);
  }
  return 0;

type_error:
  if (flags) {
    if (ty) {
      char *temp = (char *) malloc(64+strlen(ty->name));
      sprintf(temp,"Type error. Expected %s", ty->name);
      PyErr_SetString(PyExc_TypeError, temp);
      free((char *) temp);
    } else {
      PyErr_SetString(PyExc_TypeError,"Expected a pointer");
    }
  }
  return -1;
}

/* Convert a packed value value */
SWIGRUNTIME(int)
SWIG_ConvertPacked(PyObject *obj, void *ptr, int sz, swig_type_info *ty, int flags) {
  swig_type_info *tc;
  char  *c;

  if ((!obj) || (!PyString_Check(obj))) goto type_error;
  c = PyString_AsString(obj);
  /* Pointer values must start with leading underscore */
  if (*c != '_') goto type_error;
  c++;
  c = SWIG_UnpackData(c,ptr,sz);
  if (ty) {
    tc = SWIG_TypeCheck(c,ty);
    if (!tc) goto type_error;
  }
  return 0;

type_error:

  if (flags) {
    if (ty) {
      char *temp = (char *) malloc(64+strlen(ty->name));
      sprintf(temp,"Type error. Expected %s", ty->name);
      PyErr_SetString(PyExc_TypeError, temp);
      free((char *) temp);
    } else {
      PyErr_SetString(PyExc_TypeError,"Expected a pointer");
    }
  }
  return -1;
}

/* Create a new pointer object */
SWIGRUNTIME(PyObject *)
SWIG_NewPointerObj(void *ptr, swig_type_info *type, int own) {
  PyObject *robj;
  if (!ptr) {
    Py_INCREF(Py_None);
    return Py_None;
  }
#ifdef SWIG_COBJECT_TYPES
  robj = PyCObject_FromVoidPtrAndDesc((void *) ptr, (char *) type->name, NULL);
#else
  {
    char result[1024];
    char *r = result;
    *(r++) = '_';
    r = SWIG_PackData(r,&ptr,sizeof(void *));
    strcpy(r,type->name);
    robj = PyString_FromString(result);
  }
#endif
  if (!robj || (robj == Py_None)) return robj;
  if (type->clientdata) {
    PyObject *inst;
    PyObject *args = Py_BuildValue((char*)"(O)", robj);
    Py_DECREF(robj);
    inst = PyObject_CallObject((PyObject *) type->clientdata, args);
    Py_DECREF(args);
    if (own) {
      PyObject *n = PyInt_FromLong(1);
      PyObject_SetAttrString(inst,(char*)"thisown",n);
      Py_DECREF(n);
    }
    robj = inst;
  }
  return robj;
}

SWIGRUNTIME(PyObject *)
SWIG_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
  char result[1024];
  char *r = result;
  if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
  *(r++) = '_';
  r = SWIG_PackData(r,ptr,sz);
  strcpy(r,type->name);
  return PyString_FromString(result);
}

/* Install Constants */
SWIGRUNTIME(void)
SWIG_InstallConstants(PyObject *d, swig_const_info constants[]) {
  int i;
  PyObject *obj;
  for (i = 0; constants[i].type; i++) {
    switch(constants[i].type) {
    case SWIG_PY_INT:
      obj = PyInt_FromLong(constants[i].lvalue);
      break;
    case SWIG_PY_FLOAT:
      obj = PyFloat_FromDouble(constants[i].dvalue);
      break;
    case SWIG_PY_STRING:
      obj = PyString_FromString((char *) constants[i].pvalue);
      break;
    case SWIG_PY_POINTER:
      obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
      break;
    case SWIG_PY_BINARY:
      obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
      break;
    default:
      obj = 0;
      break;
    }
    if (obj) {
      PyDict_SetItemString(d,constants[i].name,obj);
      Py_DECREF(obj);
    }
  }
}

#endif

#ifdef __cplusplus
}
#endif








/* -------- TYPES TABLE (BEGIN) -------- */

static swig_type_info *swig_types[1];

/* -------- TYPES TABLE (END) -------- */

#define SWIG_init    initGLUT

#define SWIG_name    "GLUT"


int __PyObject_AsArray_Size(PyObject* x);

#ifdef NUMERIC

#define _PyObject_AsArray_Size(x) ((x == Py_None) ? 0 : ((PyArray_Check(x)) ? PyArray_Size(x) : __PyObject_AsArray_Size(x)))

#else /* NUMERIC */

#define _PyObject_AsArray_Size(x) ((x == Py_None) ? 0 : __PyObject_AsArray_Size(x))

#endif /* NUMERIC */


#define _PyObject_As(NAME, BASE) BASE* _PyObject_As##NAME(PyObject* source, PyObject** temp, int* len);

#define _PyObject_AsArray_Cleanup(target, temp) if (temp) Py_XDECREF(temp); else PyMem_Del(target)

_PyObject_As(FloatArray, float)

_PyObject_As(DoubleArray, double)

_PyObject_As(CharArray, signed char)

_PyObject_As(UnsignedCharArray, unsigned char)

_PyObject_As(ShortArray, short)

_PyObject_As(UnsignedShortArray, unsigned short)

_PyObject_As(IntArray, int)

_PyObject_As(UnsignedIntArray, unsigned int)

void* _PyObject_AsArray(GLenum type, PyObject* source, PyObject** temp, int* len);




#define PyErr_XPrint() if (PyErr_Occurred()) PyErr_Print()


#if HAS_DYNAMIC_EXT

#define DECLARE_EXT(PROC_NAME, RET, ERROR_RET, PROTO, CALL)\
RET PROC_NAME PROTO\
{\
	typedef RET (APIENTRY *proc_##PROC_NAME) PROTO;\
	proc_##PROC_NAME proc = (proc_##PROC_NAME)GL_GetProcAddress(#PROC_NAME);\
	if (proc) return proc CALL;\
	PyErr_SetGLErrorMessage( GL_INVALID_OPERATION, "Dynamic function loading not implemented/supported on this platform" );\
	return ERROR_RET;\
}

#define DECLARE_VOID_EXT(PROC_NAME, PROTO, CALL)\
void PROC_NAME PROTO\
{\
	typedef void (APIENTRY *proc_##PROC_NAME) PROTO;\
	proc_##PROC_NAME proc = (proc_##PROC_NAME)GL_GetProcAddress(#PROC_NAME);\
	if (proc) proc CALL;\
	else {\
		PyErr_SetGLErrorMessage( GL_INVALID_OPERATION, "Dynamic function loading not implemented/supported on this platform" );\
	}\
}

#else

#define DECLARE_EXT(PROC_NAME, RET, ERROR_RET, PROTO, CALL)\
RET PROC_NAME PROTO\
{\
	PyErr_SetGLErrorMessage( GL_INVALID_OPERATION, "Dynamic function loading not implemented/supported on this platform" );\
	return ERROR_RET;\
}


#define DECLARE_VOID_EXT(PROC_NAME, PROTO, CALL)\
void PROC_NAME PROTO\
{\
	PyErr_SetGLErrorMessage( GL_INVALID_OPERATION, "Dynamic function loading not implemented/supported on this platform" );\
}

#endif


#define _PyTuple_From(NAME, BASE) PyObject* _PyTuple_From##NAME(int len, BASE* data);

_PyTuple_From(UnsignedCharArray, unsigned char)

_PyTuple_From(CharArray, signed char)

_PyTuple_From(UnsignedShortArray, unsigned short)

_PyTuple_From(ShortArray, short)

_PyTuple_From(UnsignedIntArray, unsigned int)

_PyTuple_From(IntArray, int)

_PyTuple_From(FloatArray, float)

_PyTuple_From(DoubleArray, double)


#define _PyObject_From(NAME, BASE) PyObject* _PyObject_From##NAME(int nd, int* dims, BASE* data, int own);

_PyObject_From(UnsignedCharArray, unsigned char)

_PyObject_From(CharArray, signed char)

_PyObject_From(UnsignedShortArray, unsigned short)

_PyObject_From(ShortArray, short)

_PyObject_From(UnsignedIntArray, unsigned int)

_PyObject_From(IntArray, int)

_PyObject_From(FloatArray, float)

_PyObject_From(DoubleArray, double)


PyObject* _PyObject_FromArray(GLenum type, int nd, int *dims, void* data, int own);

void* SetupPixelRead(int rank, GLenum format, GLenum type, int *dims);

void SetupPixelWrite(int rank);

void* SetupRawPixelRead(GLenum format, GLenum type, int n, const int *dims, int* size);

void* _PyObject_AsPointer(PyObject* x);

/* The following line causes a warning on linux and cygwin

	The function is defined in interface_utils.c, which is
	linked to each extension module.  For some reason, though,
	this declaration doesn't get recognised as a declaration
	prototype for that function.
*/
void init_util();

typedef void *PTR;

typedef struct
{
	void (*_decrement)(void* pointer);
	void (*_decrementPointer)(GLenum pname);
	int (*_incrementLock)(void *pointer);
	int (*_incrementPointerLock)(GLenum pname);
	void (*_acquire)(void* pointer);
	void (*_acquirePointer)(GLenum pname);
#if HAS_DYNAMIC_EXT
	PTR (*GL_GetProcAddress)(const char* name);
#endif
	int (*InitExtension)(const char *name, const char** procs);
	PyObject *_GLerror;
	PyObject *_GLUerror;
}  util_API;



static util_API *_util_API = NULL;

#define decrementLock(x) (*_util_API)._decrement(x)
#define decrementPointerLock(x) (*_util_API)._decrementPointer(x)
#define incrementLock(x) (*_util_API)._incrementLock(x)
#define incrementPointerLock(x) (*_util_API)._incrementPointerLock(x)
#define acquire(x) (*_util_API)._acquire(x)
#define acquirePointer(x) (*_util_API)._acquirePointer(x)
#define GLerror (*_util_API)._GLerror
#define GLUerror (*_util_API)._GLUerror
#if HAS_DYNAMIC_EXT
#define GL_GetProcAddress(x) (*_util_API).GL_GetProcAddress(x)
#endif
#define InitExtension(x, y) (*_util_API).InitExtension(x, (const char**)y)



#define PyErr_SetGLerror(code) PyErr_SetObject(GLerror, Py_BuildValue("is", code, gluErrorString(code)));
#define PyErr_SetGLUerror(code) PyErr_SetObject(GLUerror, Py_BuildValue("is", code, gluErrorString(code)));

int _PyObject_Dimension(PyObject* x, int rank);

#define ERROR_MSG_SEP ", "
#define ERROR_MSG_SEP_LEN 2

int GLErrOccurred()
{
	if (PyErr_Occurred()) return 1;

	if (CurrentContextIsValid())
	{
		GLenum error, *errors = NULL;
		char *msg = NULL;
		const char *this_msg;
		int count = 0;
	
		error = glGetError();

		while (error != GL_NO_ERROR)
		{
			this_msg = gluErrorString(error);
			if (count)
			{
				msg = realloc(msg, (strlen(msg) + strlen(this_msg) + ERROR_MSG_SEP_LEN + 1)*sizeof(char));
				strcat(msg, ERROR_MSG_SEP);
				strcat(msg, this_msg);
				
				errors = realloc(errors, (count + 1)*sizeof(GLenum));
			}
			else
			{
				msg = malloc((strlen(this_msg) + 1)*sizeof(char));
				strcpy(msg, this_msg);
				
				errors = malloc(sizeof(GLenum));
			}
			
			errors[count++] = error;
			error = glGetError();
		}
		
		if (count)
		{
			PyErr_SetObject(GLerror, Py_BuildValue("Os", _PyTuple_FromIntArray(count, (int*)errors), msg));
			free(errors);
			free(msg);
			return 1;
		}
	}

	return 0;
}

void PyErr_SetGLErrorMessage( int id, char * message ) {
	/* set a GLerror with an ID and string message
	
	This tries pretty hard to look just like a regular
	error as produced by GLErrOccurred()'s formatter,
	save that there's only the single error being reported.

	Using id 0 is probably best for any future use where 
	there isn't a good match for the exception description
	in the error-enumeration set.
	 */
	PyObject * args = NULL;
	args = Py_BuildValue( "(i)s", id, message );
	if (args) {
		PyErr_SetObject( GLerror, args );
		Py_XDECREF( args );
	} else {
		PyErr_SetGLerror(id);
	}
}




/*
#
# GLUT Module for PyOpenGL
#  
# Date: May 2001
# 
# This module is derived from PyGLUT, by Andrew Cox
# 
# Authors: Tarn Weisner Burton <twburton@users.sourceforge.net>
#          Mike C. Fletcher
# 
#
#
# This file is derived from the glut.h distributed with GLUT 3.7. 
# It is a complete wrapper for GLUT API version 4 (provisional) including the 
# game functionality. 
# 
# The conversion to a SWIG interface file was done by me: 
# Andrew Cox (acox@globalnet.co.uk). 
# Any correspondence about PyGlut should be directed to me. 
# 
# Any updates will be made available at my homepage: 
# http://www.users.globalnet.co.uk/~acox/ 
# 
# I place no additional limitations on what can be done with the contents of 
# this file beyond those it inherits from GLUT. 
# 
# DISCLAIMER: 
# PyGlut is provided AS IS without warranty of any kind, either express or 
# implied, including but not limited to the implied warranties of 
# merchantability and fitness for a particular purpose. In no event shall 
# Andrew Cox be liable for any damages whatsoever including direct, indirect, 
# incidental, consequential, loss of business profits or special damages, 
# even if Andrew Cox has been advised of the possibility of such damages.
#
# Copyright (c) Mark J. Kilgard, 1994, 1995, 1996, 1998.
#
# This program is freely distributable without licensing fees  and is
#  provided without guarantee or warrantee expressed or  implied. This
#  program is -not- in the public domain. 
# 
# ToDo:  
# > Rather than refcounting menu callbacks passed in, do something less fragile 
#   in the face of misuse of Glut's Create/Destroy interface. 
# */


#if defined(__APPLE__) || defined(MACOSX)
/* Apple's GLUT changes directory after glutInit, you probably don't want that to happen, so we undo it :) */
#include <unistd.h>
#include <sys/param.h>
#endif

PyObject *_glutInit(PyObject* args)
{
	int argc, i;
	char **argv;
	PyObject *o, *s;
	
#if defined(__APPLE__) || defined(MACOSX)
	/* store path before glut messes it up on osx */
	char apple_preserve_path[MAXPATHLEN];
	getcwd(apple_preserve_path, MAXPATHLEN);
#endif
	if (!PyString_Check(args) && PySequence_Check(args))
	{
		argc = PySequence_Size(args);

		if (argc == 0)
		{
			argv = PyMem_New(char*, argc = 1);
			argv[0] = "foo";
		}
		else
		{
			argv = PyMem_New(char*, argc);
			for (i = 0; i < argc; i++)
			{
				o = PySequence_GetItem(args, i);
				s = PyObject_Str(o);
				
				if (s)
				{
					argv[i] = PyString_AsString(s);
					Py_DECREF(o);
					Py_DECREF(s);
				}
				else
				{
					PyMem_Del(argv);
					Py_DECREF(o);
					PyErr_SetString(PyExc_TypeError, "list must contain strings");
					return NULL;
				}
			}
		}
	}
	else
	{
		PyErr_SetString(PyExc_TypeError, "not a list");
		return NULL;
	}
	
	glutInit(&argc, argv);

#if defined(__APPLE__) || defined(MACOSX)
	/* switch back to original path on OSX */
	chdir(apple_preserve_path);
#endif
	
	o = PyList_New(argc);
	for (i = 0; i < argc; i++) PyList_SetItem(o, i, PyString_FromString(argv[i]));
	PyMem_Del(argv);

	return o;
}

 static char _doc_glutInit[] = "glutInit(argv) -> argv"; 
 static char _doc_glutInitDisplayMode[] = "glutInitDisplayMode(mode) -> None"; 
 static char _doc_glutInitWindowPosition[] = "glutInitWindowPosition(x, y) -> None"; 
 static char _doc_glutInitWindowSize[] = "glutInitWindowSize(width, height) -> None"; 
 static char _doc_glutMainLoop[] = "glutMainLoop() -> None"; 

PyObject *windows, *menus;

/* glutXXXFunc implementation, e.g. glutDisplayFunc */
int setCallback(const char* name, PyObject* func)
{
	PyObject *window_id = NULL;
	PyObject *window = NULL;
	int iwindow_id = glutGetWindow();
	if (iwindow_id) {
		/* there is a currently-defined window */
		window_id = PyInt_FromLong(iwindow_id);
		window = PyDict_GetItem(windows, window_id);

		if (!window)
		{
			window = PyDict_New();
			PyDict_SetItem(windows, window_id, window);
		}
		Py_DECREF(window_id);
		PyDict_SetItemString(window, (char*)name, func);
		return 1;
	} else {
		/* no currently defined window */
		PyErr_SetString(PyExc_RuntimeError, "Attempted to set callback with no active window");
		return 0;
	}
}

PyObject *getCallback(const char* name)
{
	PyObject *window_id = PyInt_FromLong(glutGetWindow());
	PyObject *window = PyDict_GetItem(windows, window_id);

	Py_DECREF(window_id);
	if (!window) return NULL;
	return PyDict_GetItemString(window, (char*)name);
}

/*
 * Utilities that build argument lists for Python callbacks and then eval them.
 */

void eval_no_args(PyObject *func)
{
	if (func && func != Py_None)
	{
		PyObject *result = PyObject_CallFunction(func, NULL);
		Py_XDECREF(result);
		PyErr_XPrint();
	}
}

void eval_1int_arg(PyObject *func, int arg1)
{
	if (func && func != Py_None)
	{
		PyObject *result = PyObject_CallFunction(func, "(i)", arg1);
		Py_XDECREF(result);
		PyErr_XPrint();
	}
}

/* Call a PyObject that takes two int arguments.*/
void eval_2int_args(PyObject *func, int arg1, int arg2)
{
	if (func && func != Py_None)
	{
		PyObject *result = PyObject_CallFunction(func, "ii", arg1, arg2);
		Py_XDECREF(result);
		PyErr_XPrint();
	}
}

void eval_3int_args(PyObject *func, int arg1, int arg2, int arg3)
{
	if (func && func != Py_None)
	{
		PyObject *result = PyObject_CallFunction(func, "iii", arg1, arg2, arg3);
		Py_XDECREF(result);
		PyErr_XPrint();
	}
}

void eval_4int_args(PyObject *func, int arg1, int arg2, int arg3, int arg4)
{
	if (func && func != Py_None)
	{
		PyObject *result = PyObject_CallFunction(func, "iiii", arg1, arg2, arg3, arg4);
		Py_XDECREF(result);
		PyErr_XPrint();
	}
}

void eval_1uchar_2int_args(PyObject *func, unsigned char arg1, int arg2, int arg3)
{
	if (func && func != Py_None)
	{
		PyObject *result = PyObject_CallFunction(func, "cii", arg1, arg2, arg3);
		Py_XDECREF(result);
		PyErr_XPrint();
	}
}


#define GLOBAL_CALLBACK(NAME)\
void _glut##NAME##Func(PyObject *pyfunc)\
{\
    PyObject *old = NAME##Func;\
    NAME##Func = pyfunc;\
    Py_XINCREF(pyfunc);\
    glut##NAME##Func((pyfunc == Py_None) ? NULL : NAME##Callback);\
    Py_XDECREF(old);\
}


#define WIN_CALLBACK(NAME)\
void _glut##NAME##Func(PyObject *pyfunc)\
{\
	if (setCallback(#NAME, pyfunc)) {\
		glut##NAME##Func((pyfunc == Py_None) ? NULL : NAME##Callback);\
	}\
}


void DisplayCallback(void)
{
	eval_no_args(getCallback("Display"));
}

WIN_CALLBACK(Display)

 static char _doc_glutDisplayFunc[] = "glutDisplayFunc(func) -> None"; 

void ReshapeCallback(int x, int y)
{
	eval_2int_args(getCallback("Reshape"), x, y);
}

WIN_CALLBACK(Reshape)

 static char _doc_glutReshapeFunc[] = "glutReshapeFunc(func) -> None"; 

void KeyboardCallback(unsigned char key, int x, int y)
{
    eval_1uchar_2int_args(getCallback("Keyboard"), key, x, y);
}

WIN_CALLBACK(Keyboard)

 static char _doc_glutKeyboardFunc[] = "glutKeyboardFunc(func) -> None"; 

void MouseCallback(int button, int state, int x, int y)
{
    eval_4int_args(getCallback("Mouse"), button, state, x, y);
}

WIN_CALLBACK(Mouse)

 static char _doc_glutMouseFunc[] = "glutMouseFunc(func) -> None"; 

void MotionCallback(int x, int y)
{
    eval_2int_args(getCallback("Motion"), x, y);
}

WIN_CALLBACK(Motion)

 static char _doc_glutMotionFunc[] = "glutMotionFunc(func) -> None"; 

void PassiveMotionCallback(int x, int y)
{
    eval_2int_args(getCallback("PassiveMotion"), x, y);
}

WIN_CALLBACK(PassiveMotion)

 static char _doc_glutPassiveMotionFunc[] = "glutPassiveMotionFunc(func) -> None"; 

void EntryCallback(int state)
{
    eval_1int_arg(getCallback("Entry"), state);
}

WIN_CALLBACK(Entry)

 static char _doc_glutEntryFunc[] = "glutEntryFunc(func) -> None"; 

void VisibilityCallback(int state)
{
    eval_1int_arg(getCallback("Visibility"), state);
}

WIN_CALLBACK(Visibility)

 static char _doc_glutVisibilityFunc[] = "glutVisibilityFunc(func) -> None"; 

void SpecialCallback(int key, int x, int y)
{
    eval_3int_args(getCallback("Special"), key, x, y);
}

WIN_CALLBACK(Special)

 static char _doc_glutSpecialFunc[] = "glutSpecialFunc(func) -> None"; 

void SpaceballMotionCallback(int x, int y, int z)
{
    eval_3int_args(getCallback("SpaceballMotion"), x, y, z);
}

WIN_CALLBACK(SpaceballMotion)

 static char _doc_glutSpaceballMotionFunc[] = "glutSpaceballMotionFunc(func) -> None"; 

void SpaceballRotateCallback(int x, int y, int z)
{
    eval_3int_args(getCallback("SpaceballRotate"), x, y, z);
}

WIN_CALLBACK(SpaceballRotate)

 static char _doc_glutSpaceballRotateFunc[] = "glutSpaceballRotateFunc(func) -> None"; 

void SpaceballButtonCallback(int button, int state)
{
    eval_2int_args(getCallback("SpaceballButton"), button, state);
}

WIN_CALLBACK(SpaceballButton)

 static char _doc_glutSpaceballButtonFunc[] = "glutSpaceballButtonFunc(func) -> None"; 

void ButtonBoxCallback(int button, int state)
{
    eval_2int_args(getCallback("ButtonBox"), button, state);
}

WIN_CALLBACK(ButtonBox)

 static char _doc_glutButtonBoxFunc[] = "glutButtonBoxFunc(func) -> None"; 

void DialsCallback(int dial, int value)
{
    eval_2int_args(getCallback("Dials"), dial, value);
}

WIN_CALLBACK(Dials)

 static char _doc_glutDialsFunc[] = "glutDialsFunc(func) -> None"; 

void TabletMotionCallback(int x, int y)
{
    eval_2int_args(getCallback("TabletMotion"), x, y);
}

WIN_CALLBACK(TabletMotion)

 static char _doc_glutTabletMotionFunc[] = "glutTabletMotionFunc(func) -> None"; 

void TabletButtonCallback(int button, int state, int x, int y)
{
    eval_4int_args(getCallback("TabletButton"), button, state, x, y);
}

WIN_CALLBACK(TabletButton)

 static char _doc_glutTabletButtonFunc[] = "glutTabletButtonFunc(func) -> None"; 

void SpecialUpCallback(int key, int x, int y)
{
    eval_3int_args(getCallback("SpecialUp"), key, x, y);
}

WIN_CALLBACK(SpecialUp)

 static char _doc_glutSpecialUpFunc[] = "glutSpecialUpFunc(func) -> None"; 

void KeyboardUpCallback(unsigned char key, int x, int y)
{
	eval_1uchar_2int_args(getCallback("KeyboardUp"), key, x, y);
}

WIN_CALLBACK(KeyboardUp)

 static char _doc_glutKeyboardUpFunc[] = "glutKeyboardUpFunc(func) -> None"; 

void JoystickCallback(unsigned int button_mask, int x, int y, int z)
{
    eval_4int_args(getCallback("Joystick"), button_mask, x, y, z);
}

void _glutJoystickFunc(PyObject * pyfunc, int poll_interval)
{
	setCallback("Joystick", pyfunc);
	glutJoystickFunc((pyfunc == Py_None) ? NULL : JoystickCallback, poll_interval);
}

 static char _doc_glutJoystickFunc[] = "glutJoystickFunc(func, poll_interval) -> None"; 

void OverlayDisplayCallback(void)
{
    eval_no_args(getCallback("OverlayDisplay"));
}

WIN_CALLBACK(OverlayDisplay)

 static char _doc_glutOverlayDisplayFunc[] = "glutOverlayDisplayFunc(func) -> None"; 

static PyObject *IdleFunc = NULL;

void IdleCallback(void)
{
    eval_no_args(IdleFunc);
}

GLOBAL_CALLBACK(Idle)

 static char _doc_glutIdleFunc[] = "glutIdleFunc(func) -> None"; 

static PyObject *TimerFunc = NULL;

void TimerCallback(int state)
{
    eval_1int_arg(TimerFunc, state);
}

void _glutTimerFunc(unsigned int millis, PyObject *pyfunc, int value)
{
    PyObject *old = TimerFunc;
    TimerFunc = pyfunc;
    Py_XINCREF(pyfunc);
    glutTimerFunc(millis, (pyfunc == Py_None) ? NULL : TimerCallback, value);
    Py_XDECREF(old);
}

 static char _doc_glutTimerFunc[] = "glutTimerFunc(millis, func, state) -> None"; 

static PyObject *MenuStateFunc = NULL;

void MenuStateCallback(int state)
{
	eval_1int_arg(MenuStateFunc, state);
}

GLOBAL_CALLBACK(MenuState)

 static char _doc_glutMenuStateFunc[] = "glutMenuStateFunc(func) -> None"; 

static PyObject *MenuStatusFunc = NULL;

void MenuStatusCallback(int status, int x, int y)
{
    eval_3int_args(MenuStatusFunc, status, x, y);
}

GLOBAL_CALLBACK(MenuStatus)

 static char _doc_glutMenuStatusFunc[] = "glutMenuStatusFunc(func) -> None"; 

static PyObject *WindowStatusFunc = NULL;

void WindowStatusCallback(int state)
{
    eval_1int_arg(WindowStatusFunc, state);
}

GLOBAL_CALLBACK(WindowStatus)

 static char _doc_glutWindowStatusFunc[] = "glutWindowStatusFunc(func) -> None"; 
 static char _doc_glutCreateWindow[] = "glutCreateWindow(title) -> win"; 
 static char _doc_glutCreateSubWindow[] = "glutCreateSubWindow(win, x, y, width, height) -> win"; 

void _glutDestroyWindow(int win)
{
	PyObject *window_id = PyInt_FromLong(win);

	PyDict_DelItem(windows, window_id);
	PyErr_Clear();
	Py_DECREF(window_id);
	
	glutDestroyWindow(win);
}

 static char _doc_glutDestroyWindow[] = "glutDestroyWindow(win) -> None"; 
 static char _doc_glutPostRedisplay[] = "glutPostRedisplay() -> None"; 
 static char _doc_glutSwapBuffers[] = "glutSwapBuffers() -> None"; 
 static char _doc_glutGetWindow[] = "glutGetWindow() -> None"; 
 static char _doc_glutSetWindow[] = "glutSetWindow() -> None"; 
 static char _doc_glutSetWindowTitle[] = "glutSetWindowTitle(title) -> None"; 
 static char _doc_glutSetIconTitle[] = "glutSetIconTitle(title) -> None"; 
 static char _doc_glutPositionWindow[] = "glutPositionWindow(x, y) -> None"; 
 static char _doc_glutReshapeWindow[] = "glutReshapeWindow(width, height) -> None"; 
 static char _doc_glutPopWindow[] = "glutPopWindow() -> None"; 
 static char _doc_glutPushWindow[] = "glutPushWindow() -> None"; 
 static char _doc_glutIconifyWindow[] = "glutIconifyWindow() -> None"; 
 static char _doc_glutShowWindow[] = "glutShowWindow() -> None"; 
 static char _doc_glutHideWindow[] = "glutHideWindow() -> None"; 

void MenuCallback(int event)
{
	PyObject *menu_id = PyInt_FromLong(glutGetMenu());
	PyObject *func = PyDict_GetItem(menus, menu_id);

	Py_DECREF(menu_id);
	eval_1int_arg(func, event);
}

int _glutCreateMenu(PyObject *pyfunc)
{
	int menu = glutCreateMenu(MenuCallback);
	PyObject *menu_id = PyInt_FromLong(menu);

	PyDict_SetItem(menus, menu_id, pyfunc);
	Py_DECREF(menu_id);

	return menu;
}

void _glutDestroyMenu(int menu)
{
	PyObject *menu_id = PyInt_FromLong(glutGetMenu());

	PyDict_DelItem(menus, menu_id);
	Py_DECREF(menu_id);
	glutDestroyMenu(menu);
}

 static char _doc_glutCreateMenu[] = "glutCreateMenu(func) -> menu"; 
 static char _doc_glutDestroyMenu[] = "glutDestroyMenu(menu) -> None"; 
 static char _doc_glutGetMenu[] = "glutGetMenu() -> mene"; 
 static char _doc_glutSetMenu[] = "glutSetMenu(menu) -> None"; 
 static char _doc_glutAddMenuEntry[] = "glutAddMenuEntry(label, value) -> None"; 
 static char _doc_glutAddSubMenu[] = "glutAddSubMenu(label, submenu) -> None"; 
 static char _doc_glutChangeToMenuEntry[] = "glutChangeToMenuEntry(item, label, value) -> None"; 
 static char _doc_glutChangeToSubMenu[] = "glutChangeToSubMenu(item, label, submenu) -> None"; 
 static char _doc_glutRemoveMenuItem[] = "glutRemoveMenuItem(item) -> None"; 
 static char _doc_glutAttachMenu[] = "glutAttachMenu(button) -> None"; 
 static char _doc_glutDetachMenu[] = "glutDetachMenu(button) -> None"; 
 static char _doc_glutSetColor[] = "glutSetColor(cell, red, green, blue) -> None"; 
 static char _doc_glutGetColor[] = "glutGetColor(ndx, component) -> None"; 
 static char _doc_glutCopyColormap[] = "glutCopyColormap(win) -> None"; 
 static char _doc_glutGet[] = "glutGet(type) -> None"; 
 static char _doc_glutDeviceGet[] = "glutDeviceGet() -> None"; 

/* On MS Windows fonts are ints disguised as void*s. On Unix they realy are 
# void*s. 
# On the Python side fonts are known by int values. */

void* _PyInt_AsFont(PyObject *x)
{
	if (PyInt_Check(x))
	{
		switch (PyInt_AsLong(x))
		{
		case 0:
			return GLUT_STROKE_ROMAN;
		case 1:
			return GLUT_STROKE_MONO_ROMAN;
		case 2:
			return GLUT_BITMAP_9_BY_15;
		case 3:
			return GLUT_BITMAP_8_BY_13;
		case 4:
			return GLUT_BITMAP_TIMES_ROMAN_10;
		case 5:
			return GLUT_BITMAP_TIMES_ROMAN_24;
#if (GLUT_API_VERSION >= 3)
		case 6:
			return GLUT_BITMAP_HELVETICA_10;
		case 7:
			return GLUT_BITMAP_HELVETICA_12;
		case 8:
			return GLUT_BITMAP_HELVETICA_18;
#endif
		}
		
		PyErr_SetString(PyExc_ValueError, "Unknown font.");
	}
	else PyErr_SetString(PyExc_ValueError, "Invalid font identifier.");
	
	return 0;
}

 static char _doc_glutBitmapCharacter[] = "glutBitmapCharacter(font, character) -> None"; 
 static char _doc_glutBitmapWidth[] = "glutBitmapWidth(font, character) -> None"; 
 static char _doc_glutStrokeCharacter[] = "glutStrokeCharacter(font, character) -> None"; 
 static char _doc_glutStrokeWidth[] = "glutStrokeWidth(font, character) -> None"; 
 static char _doc_glutWireSphere[] = "glutWireSphere(radius, slices, stacks) -> None"; 
 static char _doc_glutSolidSphere[] = "glutSolidSphere(radius, slices, stacks) -> None"; 
 static char _doc_glutWireCone[] = "glutWireCone(base, height, slices, stacks) -> None"; 
 static char _doc_glutSolidCone[] = "glutSolidCone(base, height, slices, stacks) -> None"; 
 static char _doc_glutWireCube[] = "glutWireCube(size) -> None"; 
 static char _doc_glutSolidCube[] = "glutSolidCube(size) -> None"; 
 static char _doc_glutWireTorus[] = "glutWireTorus(innerRadius, outerRadius, size, rings) -> None"; 
 static char _doc_glutSolidTorus[] = "glutSolidTorus(innerRadius, outerRadius, size, rings) -> None"; 
 static char _doc_glutWireDodecahedron[] = "glutWireDodecahedron() -> None"; 
 static char _doc_glutSolidDodecahedron[] = "glutSolidDodecahedron() -> None"; 
 static char _doc_glutWireTeapot[] = "glutWireTeapot(size) -> None"; 
 static char _doc_glutSolidTeapot[] = "glutSolidTeapot(size) -> None"; 
 static char _doc_glutWireOctahedron[] = "glutWireOctahedron() -> None"; 
 static char _doc_glutSolidOctahedron[] = "glutSolidOctahedron() -> None"; 
 static char _doc_glutWireTetrahedron[] = "glutWireTetrahedron() -> None"; 
 static char _doc_glutSolidTetrahedron[] = "glutSolidTetrahedron() -> None"; 
 static char _doc_glutWireIcosahedron[] = "glutWireIcosahedron() -> None"; 
 static char _doc_glutSolidIcosahedron[] = "glutSolidIcosahedron() -> None"; 
 static char _doc_glutExtensionSupported[] = "glutExtensionSupported(name) -> int"; 
 static char _doc_glutFullScreen[] = "glutFullScreen() -> None"; 
 static char _doc_glutSetCursor[] = "glutSetCursor(cursor) -> None"; 
 static char _doc_glutEstablishOverlay[] = "glutEstablishOverlay() -> None"; 
 static char _doc_glutRemoveOverlay[] = "glutRemoveOverlay(func) -> None"; 
 static char _doc_glutUseLayer[] = "glutUseLayer(layer) -> None"; 
 static char _doc_glutPostOverlayRedisplay[] = "glutPostOverlayRedisplay() -> None"; 
 static char _doc_glutShowOverlay[] = "glutShowOverlay() -> None"; 
 static char _doc_glutHideOverlay[] = "glutHideOverlay() -> None"; 
 static char _doc_glutGetModifiers[] = "glutGetModifiers() -> None"; 
 static char _doc_glutLayerGet[] = "glutLayerGet(type) -> None"; 
 static char _doc_glutWarpPointer[] = "glutWarpPointer(x, y) -> None"; 
 static char _doc_glutVideoResizeGet[] = "glutVideoResizeGet(param) -> None"; 
 static char _doc_glutSetupVideoResizing[] = "glutSetupVideoResizing() -> None"; 
 static char _doc_glutStopVideoResizing[] = "glutStopVideoResizing() -> None"; 
 static char _doc_glutVideoResize[] = "glutVideoResize(x, y, width, height) -> None"; 
 static char _doc_glutVideoPan[] = "glutVideoPan(x, y, width, height) -> None"; 
 static char _doc_glutInitDisplayString[] = "glutInitDisplayString(string) -> None"; 
 static char _doc_glutBitmapLength[] = "glutBitmapLength(font, string) -> None"; 
 static char _doc_glutStrokeLength[] = "glutStrokeLength(font, string) -> None"; 
 static char _doc_glutReportErrors[] = "glutReportErrors() -> None"; 
 static char _doc_glutPostWindowRedisplay[] = "glutPostWindowRedisplay(win) -> None"; 
 static char _doc_glutPostWindowOverlayRedisplay[] = "glutPostWindowOverlayRedisplay(win) -> None"; 
 static char _doc_glutIgnoreKeyRepeat[] = "glutIgnoreKeyRepeat() -> None"; 
 static char _doc_glutSetKeyRepeat[] = "glutSetKeyRepeat(repeatMode) -> None"; 
 static char _doc_glutForceJoystickFunc[] = "glutForceJoystickFunc() -> None"; 
 static char _doc_glutGameModeString[] = "glutGameModeString(string) -> None"; 
 static char _doc_glutEnterGameMode[] = "glutEnterGameMode() -> None"; 
 static char _doc_glutLeaveGameMode[] = "glutLeaveGameMode() -> None"; 
 static char _doc_glutGameModeGet[] = "glutGameModeGet(mode) -> None"; 

PyObject *__info()
{
	return PyList_New(0);
}

#ifdef __cplusplus
extern "C" {
#endif
static PyObject *_wrap_glutInit(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    PyObject *arg1 ;
    PyObject *result;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glutInit",&obj0)) return NULL;
    {
        arg1 = obj0;
    }
    {
        result = (PyObject *)_glutInit(arg1);
        if (PyErr_Occurred()) return NULL; 
    }
    {
        resultobj= result;
    }
    return resultobj;
}


static PyObject *_wrap_glutInitDisplayMode(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    unsigned int arg1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glutInitDisplayMode",&obj0)) return NULL;
    arg1 = (unsigned int) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        glutInitDisplayMode(arg1);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutInitWindowPosition(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    int arg1 ;
    int arg2 ;
    
    if(!PyArg_ParseTuple(args,(char *)"ii:glutInitWindowPosition",&arg1,&arg2)) return NULL;
    {
        glutInitWindowPosition(arg1,arg2);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutInitWindowSize(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    int arg1 ;
    int arg2 ;
    
    if(!PyArg_ParseTuple(args,(char *)"ii:glutInitWindowSize",&arg1,&arg2)) return NULL;
    {
        glutInitWindowSize(arg1,arg2);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutMainLoop(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    
    if(!PyArg_ParseTuple(args,(char *)":glutMainLoop")) return NULL;
    {
        glutMainLoop();
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutDisplayFunc(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    PyObject *arg1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glutDisplayFunc",&obj0)) return NULL;
    {
        if (obj0 != Py_None && !PyCallable_Check(obj0))
        {
            PyErr_SetString(PyExc_Exception, "Not callable.");
            return NULL;
        }
        arg1 = obj0;
    }
    {
        _glutDisplayFunc(arg1);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutReshapeFunc(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    PyObject *arg1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glutReshapeFunc",&obj0)) return NULL;
    {
        if (obj0 != Py_None && !PyCallable_Check(obj0))
        {
            PyErr_SetString(PyExc_Exception, "Not callable.");
            return NULL;
        }
        arg1 = obj0;
    }
    {
        _glutReshapeFunc(arg1);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutKeyboardFunc(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    PyObject *arg1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glutKeyboardFunc",&obj0)) return NULL;
    {
        if (obj0 != Py_None && !PyCallable_Check(obj0))
        {
            PyErr_SetString(PyExc_Exception, "Not callable.");
            return NULL;
        }
        arg1 = obj0;
    }
    {
        _glutKeyboardFunc(arg1);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutMouseFunc(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    PyObject *arg1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glutMouseFunc",&obj0)) return NULL;
    {
        if (obj0 != Py_None && !PyCallable_Check(obj0))
        {
            PyErr_SetString(PyExc_Exception, "Not callable.");
            return NULL;
        }
        arg1 = obj0;
    }
    {
        _glutMouseFunc(arg1);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutMotionFunc(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    PyObject *arg1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glutMotionFunc",&obj0)) return NULL;
    {
        if (obj0 != Py_None && !PyCallable_Check(obj0))
        {
            PyErr_SetString(PyExc_Exception, "Not callable.");
            return NULL;
        }
        arg1 = obj0;
    }
    {
        _glutMotionFunc(arg1);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutPassiveMotionFunc(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    PyObject *arg1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glutPassiveMotionFunc",&obj0)) return NULL;
    {
        if (obj0 != Py_None && !PyCallable_Check(obj0))
        {
            PyErr_SetString(PyExc_Exception, "Not callable.");
            return NULL;
        }
        arg1 = obj0;
    }
    {
        _glutPassiveMotionFunc(arg1);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutEntryFunc(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    PyObject *arg1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glutEntryFunc",&obj0)) return NULL;
    {
        if (obj0 != Py_None && !PyCallable_Check(obj0))
        {
            PyErr_SetString(PyExc_Exception, "Not callable.");
            return NULL;
        }
        arg1 = obj0;
    }
    {
        _glutEntryFunc(arg1);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutVisibilityFunc(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    PyObject *arg1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glutVisibilityFunc",&obj0)) return NULL;
    {
        if (obj0 != Py_None && !PyCallable_Check(obj0))
        {
            PyErr_SetString(PyExc_Exception, "Not callable.");
            return NULL;
        }
        arg1 = obj0;
    }
    {
        _glutVisibilityFunc(arg1);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutSpecialFunc(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    PyObject *arg1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glutSpecialFunc",&obj0)) return NULL;
    {
        if (obj0 != Py_None && !PyCallable_Check(obj0))
        {
            PyErr_SetString(PyExc_Exception, "Not callable.");
            return NULL;
        }
        arg1 = obj0;
    }
    {
        _glutSpecialFunc(arg1);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutSpaceballMotionFunc(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    PyObject *arg1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glutSpaceballMotionFunc",&obj0)) return NULL;
    {
        if (obj0 != Py_None && !PyCallable_Check(obj0))
        {
            PyErr_SetString(PyExc_Exception, "Not callable.");
            return NULL;
        }
        arg1 = obj0;
    }
    {
        _glutSpaceballMotionFunc(arg1);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutSpaceballRotateFunc(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    PyObject *arg1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glutSpaceballRotateFunc",&obj0)) return NULL;
    {
        if (obj0 != Py_None && !PyCallable_Check(obj0))
        {
            PyErr_SetString(PyExc_Exception, "Not callable.");
            return NULL;
        }
        arg1 = obj0;
    }
    {
        _glutSpaceballRotateFunc(arg1);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutSpaceballButtonFunc(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    PyObject *arg1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glutSpaceballButtonFunc",&obj0)) return NULL;
    {
        if (obj0 != Py_None && !PyCallable_Check(obj0))
        {
            PyErr_SetString(PyExc_Exception, "Not callable.");
            return NULL;
        }
        arg1 = obj0;
    }
    {
        _glutSpaceballButtonFunc(arg1);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutButtonBoxFunc(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    PyObject *arg1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glutButtonBoxFunc",&obj0)) return NULL;
    {
        if (obj0 != Py_None && !PyCallable_Check(obj0))
        {
            PyErr_SetString(PyExc_Exception, "Not callable.");
            return NULL;
        }
        arg1 = obj0;
    }
    {
        _glutButtonBoxFunc(arg1);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutDialsFunc(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    PyObject *arg1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glutDialsFunc",&obj0)) return NULL;
    {
        if (obj0 != Py_None && !PyCallable_Check(obj0))
        {
            PyErr_SetString(PyExc_Exception, "Not callable.");
            return NULL;
        }
        arg1 = obj0;
    }
    {
        _glutDialsFunc(arg1);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutTabletMotionFunc(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    PyObject *arg1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glutTabletMotionFunc",&obj0)) return NULL;
    {
        if (obj0 != Py_None && !PyCallable_Check(obj0))
        {
            PyErr_SetString(PyExc_Exception, "Not callable.");
            return NULL;
        }
        arg1 = obj0;
    }
    {
        _glutTabletMotionFunc(arg1);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutTabletButtonFunc(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    PyObject *arg1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glutTabletButtonFunc",&obj0)) return NULL;
    {
        if (obj0 != Py_None && !PyCallable_Check(obj0))
        {
            PyErr_SetString(PyExc_Exception, "Not callable.");
            return NULL;
        }
        arg1 = obj0;
    }
    {
        _glutTabletButtonFunc(arg1);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutSpecialUpFunc(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    PyObject *arg1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glutSpecialUpFunc",&obj0)) return NULL;
    {
        if (obj0 != Py_None && !PyCallable_Check(obj0))
        {
            PyErr_SetString(PyExc_Exception, "Not callable.");
            return NULL;
        }
        arg1 = obj0;
    }
    {
        _glutSpecialUpFunc(arg1);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutKeyboardUpFunc(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    PyObject *arg1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glutKeyboardUpFunc",&obj0)) return NULL;
    {
        if (obj0 != Py_None && !PyCallable_Check(obj0))
        {
            PyErr_SetString(PyExc_Exception, "Not callable.");
            return NULL;
        }
        arg1 = obj0;
    }
    {
        _glutKeyboardUpFunc(arg1);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutJoystickFunc(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    PyObject *arg1 ;
    int arg2 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"Oi:glutJoystickFunc",&obj0,&arg2)) return NULL;
    {
        if (obj0 != Py_None && !PyCallable_Check(obj0))
        {
            PyErr_SetString(PyExc_Exception, "Not callable.");
            return NULL;
        }
        arg1 = obj0;
    }
    {
        _glutJoystickFunc(arg1,arg2);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutOverlayDisplayFunc(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    PyObject *arg1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glutOverlayDisplayFunc",&obj0)) return NULL;
    {
        if (obj0 != Py_None && !PyCallable_Check(obj0))
        {
            PyErr_SetString(PyExc_Exception, "Not callable.");
            return NULL;
        }
        arg1 = obj0;
    }
    {
        _glutOverlayDisplayFunc(arg1);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutIdleFunc(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    PyObject *arg1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glutIdleFunc",&obj0)) return NULL;
    {
        if (obj0 != Py_None && !PyCallable_Check(obj0))
        {
            PyErr_SetString(PyExc_Exception, "Not callable.");
            return NULL;
        }
        arg1 = obj0;
    }
    {
        _glutIdleFunc(arg1);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutTimerFunc(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    unsigned int arg1 ;
    PyObject *arg2 ;
    int arg3 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OOi:glutTimerFunc",&obj0,&obj1,&arg3)) return NULL;
    arg1 = (unsigned int) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        if (obj1 != Py_None && !PyCallable_Check(obj1))
        {
            PyErr_SetString(PyExc_Exception, "Not callable.");
            return NULL;
        }
        arg2 = obj1;
    }
    {
        _glutTimerFunc(arg1,arg2,arg3);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutMenuStateFunc(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    PyObject *arg1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glutMenuStateFunc",&obj0)) return NULL;
    {
        if (obj0 != Py_None && !PyCallable_Check(obj0))
        {
            PyErr_SetString(PyExc_Exception, "Not callable.");
            return NULL;
        }
        arg1 = obj0;
    }
    {
        _glutMenuStateFunc(arg1);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutMenuStatusFunc(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    PyObject *arg1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glutMenuStatusFunc",&obj0)) return NULL;
    {
        if (obj0 != Py_None && !PyCallable_Check(obj0))
        {
            PyErr_SetString(PyExc_Exception, "Not callable.");
            return NULL;
        }
        arg1 = obj0;
    }
    {
        _glutMenuStatusFunc(arg1);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutWindowStatusFunc(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    PyObject *arg1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glutWindowStatusFunc",&obj0)) return NULL;
    {
        if (obj0 != Py_None && !PyCallable_Check(obj0))
        {
            PyErr_SetString(PyExc_Exception, "Not callable.");
            return NULL;
        }
        arg1 = obj0;
    }
    {
        _glutWindowStatusFunc(arg1);
        if (PyErr_Occurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutCreateWindow(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    char *arg1 ;
    int result;
    
    if(!PyArg_ParseTuple(args,(char *)"s:glutCreateWindow",&arg1)) return NULL;
    {
        result = (int)glutCreateWindow((char const *)arg1);
        if (GLErrOccurred()) return NULL; 
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
}


static PyObject *_wrap_glutCreateSubWindow(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    int arg1 ;
    int arg2 ;
    int arg3 ;
    int arg4 ;
    int arg5 ;
    int result;
    
    if(!PyArg_ParseTuple(args,(char *)"iiiii:glutCreateSubWindow",&arg1,&arg2,&arg3,&arg4,&arg5)) return NULL;
    {
        result = (int)glutCreateSubWindow(arg1,arg2,arg3,arg4,arg5);
        if (GLErrOccurred()) return NULL; 
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
}


static PyObject *_wrap_glutDestroyWindow(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    int arg1 ;
    
    if(!PyArg_ParseTuple(args,(char *)"i:glutDestroyWindow",&arg1)) return NULL;
    {
        _glutDestroyWindow(arg1);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutPostRedisplay(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    
    if(!PyArg_ParseTuple(args,(char *)":glutPostRedisplay")) return NULL;
    {
        glutPostRedisplay();
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutSwapBuffers(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    
    if(!PyArg_ParseTuple(args,(char *)":glutSwapBuffers")) return NULL;
    {
        glutSwapBuffers();
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutGetWindow(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    int result;
    
    if(!PyArg_ParseTuple(args,(char *)":glutGetWindow")) return NULL;
    {
        result = (int)glutGetWindow();
        if (GLErrOccurred()) return NULL; 
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
}


static PyObject *_wrap_glutSetWindow(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    int arg1 ;
    
    if(!PyArg_ParseTuple(args,(char *)"i:glutSetWindow",&arg1)) return NULL;
    {
        glutSetWindow(arg1);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutSetWindowTitle(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    char *arg1 ;
    
    if(!PyArg_ParseTuple(args,(char *)"s:glutSetWindowTitle",&arg1)) return NULL;
    {
        glutSetWindowTitle((char const *)arg1);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutSetIconTitle(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    char *arg1 ;
    
    if(!PyArg_ParseTuple(args,(char *)"s:glutSetIconTitle",&arg1)) return NULL;
    {
        glutSetIconTitle((char const *)arg1);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutPositionWindow(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    int arg1 ;
    int arg2 ;
    
    if(!PyArg_ParseTuple(args,(char *)"ii:glutPositionWindow",&arg1,&arg2)) return NULL;
    {
        glutPositionWindow(arg1,arg2);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutReshapeWindow(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    int arg1 ;
    int arg2 ;
    
    if(!PyArg_ParseTuple(args,(char *)"ii:glutReshapeWindow",&arg1,&arg2)) return NULL;
    {
        glutReshapeWindow(arg1,arg2);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutPopWindow(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    
    if(!PyArg_ParseTuple(args,(char *)":glutPopWindow")) return NULL;
    {
        glutPopWindow();
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutPushWindow(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    
    if(!PyArg_ParseTuple(args,(char *)":glutPushWindow")) return NULL;
    {
        glutPushWindow();
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutIconifyWindow(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    
    if(!PyArg_ParseTuple(args,(char *)":glutIconifyWindow")) return NULL;
    {
        glutIconifyWindow();
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutShowWindow(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    
    if(!PyArg_ParseTuple(args,(char *)":glutShowWindow")) return NULL;
    {
        glutShowWindow();
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutHideWindow(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    
    if(!PyArg_ParseTuple(args,(char *)":glutHideWindow")) return NULL;
    {
        glutHideWindow();
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutCreateMenu(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    PyObject *arg1 ;
    int result;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glutCreateMenu",&obj0)) return NULL;
    {
        if (obj0 != Py_None && !PyCallable_Check(obj0))
        {
            PyErr_SetString(PyExc_Exception, "Not callable.");
            return NULL;
        }
        arg1 = obj0;
    }
    {
        result = (int)_glutCreateMenu(arg1);
        if (GLErrOccurred()) return NULL; 
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
}


static PyObject *_wrap_glutDestroyMenu(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    int arg1 ;
    
    if(!PyArg_ParseTuple(args,(char *)"i:glutDestroyMenu",&arg1)) return NULL;
    {
        _glutDestroyMenu(arg1);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutGetMenu(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    int result;
    
    if(!PyArg_ParseTuple(args,(char *)":glutGetMenu")) return NULL;
    {
        result = (int)glutGetMenu();
        if (GLErrOccurred()) return NULL; 
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
}


static PyObject *_wrap_glutSetMenu(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    int arg1 ;
    
    if(!PyArg_ParseTuple(args,(char *)"i:glutSetMenu",&arg1)) return NULL;
    {
        glutSetMenu(arg1);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutAddMenuEntry(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    char *arg1 ;
    int arg2 ;
    
    if(!PyArg_ParseTuple(args,(char *)"si:glutAddMenuEntry",&arg1,&arg2)) return NULL;
    {
        glutAddMenuEntry((char const *)arg1,arg2);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutAddSubMenu(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    char *arg1 ;
    int arg2 ;
    
    if(!PyArg_ParseTuple(args,(char *)"si:glutAddSubMenu",&arg1,&arg2)) return NULL;
    {
        glutAddSubMenu((char const *)arg1,arg2);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutChangeToMenuEntry(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    int arg1 ;
    char *arg2 ;
    int arg3 ;
    
    if(!PyArg_ParseTuple(args,(char *)"isi:glutChangeToMenuEntry",&arg1,&arg2,&arg3)) return NULL;
    {
        glutChangeToMenuEntry(arg1,(char const *)arg2,arg3);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutChangeToSubMenu(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    int arg1 ;
    char *arg2 ;
    int arg3 ;
    
    if(!PyArg_ParseTuple(args,(char *)"isi:glutChangeToSubMenu",&arg1,&arg2,&arg3)) return NULL;
    {
        glutChangeToSubMenu(arg1,(char const *)arg2,arg3);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutRemoveMenuItem(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    int arg1 ;
    
    if(!PyArg_ParseTuple(args,(char *)"i:glutRemoveMenuItem",&arg1)) return NULL;
    {
        glutRemoveMenuItem(arg1);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutAttachMenu(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    int arg1 ;
    
    if(!PyArg_ParseTuple(args,(char *)"i:glutAttachMenu",&arg1)) return NULL;
    {
        glutAttachMenu(arg1);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutDetachMenu(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    int arg1 ;
    
    if(!PyArg_ParseTuple(args,(char *)"i:glutDetachMenu",&arg1)) return NULL;
    {
        glutDetachMenu(arg1);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutSetColor(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    int arg1 ;
    GLfloat arg2 ;
    GLfloat arg3 ;
    GLfloat arg4 ;
    
    if(!PyArg_ParseTuple(args,(char *)"ifff:glutSetColor",&arg1,&arg2,&arg3,&arg4)) return NULL;
    {
        glutSetColor(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutGetColor(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    int arg1 ;
    int arg2 ;
    GLfloat result;
    
    if(!PyArg_ParseTuple(args,(char *)"ii:glutGetColor",&arg1,&arg2)) return NULL;
    {
        result = (GLfloat)glutGetColor(arg1,arg2);
        if (GLErrOccurred()) return NULL; 
    }
    resultobj = PyFloat_FromDouble(result);
    return resultobj;
}


static PyObject *_wrap_glutCopyColormap(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    int arg1 ;
    
    if(!PyArg_ParseTuple(args,(char *)"i:glutCopyColormap",&arg1)) return NULL;
    {
        glutCopyColormap(arg1);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutGet(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    int result;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glutGet",&obj0)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        result = (int)glutGet(arg1);
        if (GLErrOccurred()) return NULL; 
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
}


static PyObject *_wrap_glutDeviceGet(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    int result;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glutDeviceGet",&obj0)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        result = (int)glutDeviceGet(arg1);
        if (GLErrOccurred()) return NULL; 
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
}


static PyObject *_wrap_glutBitmapCharacter(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    void *arg1 ;
    int arg2 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"Oi:glutBitmapCharacter",&obj0,&arg2)) return NULL;
    {
        arg1 = _PyInt_AsFont(obj0);
        if (PyErr_Occurred()) return NULL;
    }
    {
        glutBitmapCharacter(arg1,arg2);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutBitmapWidth(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    void *arg1 ;
    int arg2 ;
    int result;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"Oi:glutBitmapWidth",&obj0,&arg2)) return NULL;
    {
        arg1 = _PyInt_AsFont(obj0);
        if (PyErr_Occurred()) return NULL;
    }
    {
        result = (int)glutBitmapWidth(arg1,arg2);
        if (GLErrOccurred()) return NULL; 
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
}


static PyObject *_wrap_glutStrokeCharacter(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    void *arg1 ;
    int arg2 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"Oi:glutStrokeCharacter",&obj0,&arg2)) return NULL;
    {
        arg1 = _PyInt_AsFont(obj0);
        if (PyErr_Occurred()) return NULL;
    }
    {
        glutStrokeCharacter(arg1,arg2);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutStrokeWidth(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    void *arg1 ;
    int arg2 ;
    int result;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"Oi:glutStrokeWidth",&obj0,&arg2)) return NULL;
    {
        arg1 = _PyInt_AsFont(obj0);
        if (PyErr_Occurred()) return NULL;
    }
    {
        result = (int)glutStrokeWidth(arg1,arg2);
        if (GLErrOccurred()) return NULL; 
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
}


static PyObject *_wrap_glutWireSphere(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    
    if(!PyArg_ParseTuple(args,(char *)"dii:glutWireSphere",&arg1,&arg2,&arg3)) return NULL;
    {
        glutWireSphere(arg1,arg2,arg3);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutSolidSphere(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLint arg2 ;
    GLint arg3 ;
    
    if(!PyArg_ParseTuple(args,(char *)"dii:glutSolidSphere",&arg1,&arg2,&arg3)) return NULL;
    {
        glutSolidSphere(arg1,arg2,arg3);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutWireCone(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    GLint arg3 ;
    GLint arg4 ;
    
    if(!PyArg_ParseTuple(args,(char *)"ddii:glutWireCone",&arg1,&arg2,&arg3,&arg4)) return NULL;
    {
        glutWireCone(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutSolidCone(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    GLint arg3 ;
    GLint arg4 ;
    
    if(!PyArg_ParseTuple(args,(char *)"ddii:glutSolidCone",&arg1,&arg2,&arg3,&arg4)) return NULL;
    {
        glutSolidCone(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutWireCube(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    
    if(!PyArg_ParseTuple(args,(char *)"d:glutWireCube",&arg1)) return NULL;
    {
        glutWireCube(arg1);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutSolidCube(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    
    if(!PyArg_ParseTuple(args,(char *)"d:glutSolidCube",&arg1)) return NULL;
    {
        glutSolidCube(arg1);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutWireTorus(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    GLint arg3 ;
    GLint arg4 ;
    
    if(!PyArg_ParseTuple(args,(char *)"ddii:glutWireTorus",&arg1,&arg2,&arg3,&arg4)) return NULL;
    {
        glutWireTorus(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutSolidTorus(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    GLdouble arg2 ;
    GLint arg3 ;
    GLint arg4 ;
    
    if(!PyArg_ParseTuple(args,(char *)"ddii:glutSolidTorus",&arg1,&arg2,&arg3,&arg4)) return NULL;
    {
        glutSolidTorus(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutWireDodecahedron(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    
    if(!PyArg_ParseTuple(args,(char *)":glutWireDodecahedron")) return NULL;
    {
        glutWireDodecahedron();
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutSolidDodecahedron(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    
    if(!PyArg_ParseTuple(args,(char *)":glutSolidDodecahedron")) return NULL;
    {
        glutSolidDodecahedron();
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutWireTeapot(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    
    if(!PyArg_ParseTuple(args,(char *)"d:glutWireTeapot",&arg1)) return NULL;
    {
        glutWireTeapot(arg1);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutSolidTeapot(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLdouble arg1 ;
    
    if(!PyArg_ParseTuple(args,(char *)"d:glutSolidTeapot",&arg1)) return NULL;
    {
        glutSolidTeapot(arg1);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutWireOctahedron(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    
    if(!PyArg_ParseTuple(args,(char *)":glutWireOctahedron")) return NULL;
    {
        glutWireOctahedron();
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutSolidOctahedron(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    
    if(!PyArg_ParseTuple(args,(char *)":glutSolidOctahedron")) return NULL;
    {
        glutSolidOctahedron();
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutWireTetrahedron(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    
    if(!PyArg_ParseTuple(args,(char *)":glutWireTetrahedron")) return NULL;
    {
        glutWireTetrahedron();
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutSolidTetrahedron(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    
    if(!PyArg_ParseTuple(args,(char *)":glutSolidTetrahedron")) return NULL;
    {
        glutSolidTetrahedron();
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutWireIcosahedron(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    
    if(!PyArg_ParseTuple(args,(char *)":glutWireIcosahedron")) return NULL;
    {
        glutWireIcosahedron();
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutSolidIcosahedron(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    
    if(!PyArg_ParseTuple(args,(char *)":glutSolidIcosahedron")) return NULL;
    {
        glutSolidIcosahedron();
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutExtensionSupported(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    char *arg1 ;
    int result;
    
    if(!PyArg_ParseTuple(args,(char *)"s:glutExtensionSupported",&arg1)) return NULL;
    {
        result = (int)glutExtensionSupported((char const *)arg1);
        if (GLErrOccurred()) return NULL; 
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
}


static PyObject *_wrap_glutFullScreen(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    
    if(!PyArg_ParseTuple(args,(char *)":glutFullScreen")) return NULL;
    {
        glutFullScreen();
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutSetCursor(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    int arg1 ;
    
    if(!PyArg_ParseTuple(args,(char *)"i:glutSetCursor",&arg1)) return NULL;
    {
        glutSetCursor(arg1);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutEstablishOverlay(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    
    if(!PyArg_ParseTuple(args,(char *)":glutEstablishOverlay")) return NULL;
    {
        glutEstablishOverlay();
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutRemoveOverlay(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    
    if(!PyArg_ParseTuple(args,(char *)":glutRemoveOverlay")) return NULL;
    {
        glutRemoveOverlay();
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutUseLayer(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glutUseLayer",&obj0)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        glutUseLayer(arg1);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutPostOverlayRedisplay(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    
    if(!PyArg_ParseTuple(args,(char *)":glutPostOverlayRedisplay")) return NULL;
    {
        glutPostOverlayRedisplay();
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutShowOverlay(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    
    if(!PyArg_ParseTuple(args,(char *)":glutShowOverlay")) return NULL;
    {
        glutShowOverlay();
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutHideOverlay(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    
    if(!PyArg_ParseTuple(args,(char *)":glutHideOverlay")) return NULL;
    {
        glutHideOverlay();
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutGetModifiers(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    int result;
    
    if(!PyArg_ParseTuple(args,(char *)":glutGetModifiers")) return NULL;
    {
        result = (int)glutGetModifiers();
        if (GLErrOccurred()) return NULL; 
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
}


static PyObject *_wrap_glutLayerGet(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    int result;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glutLayerGet",&obj0)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        result = (int)glutLayerGet(arg1);
        if (GLErrOccurred()) return NULL; 
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
}


static PyObject *_wrap_glutWarpPointer(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    int arg1 ;
    int arg2 ;
    
    if(!PyArg_ParseTuple(args,(char *)"ii:glutWarpPointer",&arg1,&arg2)) return NULL;
    {
        glutWarpPointer(arg1,arg2);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutVideoResizeGet(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    int result;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glutVideoResizeGet",&obj0)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        result = (int)glutVideoResizeGet(arg1);
        if (GLErrOccurred()) return NULL; 
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
}


static PyObject *_wrap_glutSetupVideoResizing(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    
    if(!PyArg_ParseTuple(args,(char *)":glutSetupVideoResizing")) return NULL;
    {
        glutSetupVideoResizing();
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutStopVideoResizing(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    
    if(!PyArg_ParseTuple(args,(char *)":glutStopVideoResizing")) return NULL;
    {
        glutStopVideoResizing();
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutVideoResize(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    int arg1 ;
    int arg2 ;
    int arg3 ;
    int arg4 ;
    
    if(!PyArg_ParseTuple(args,(char *)"iiii:glutVideoResize",&arg1,&arg2,&arg3,&arg4)) return NULL;
    {
        glutVideoResize(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutVideoPan(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    int arg1 ;
    int arg2 ;
    int arg3 ;
    int arg4 ;
    
    if(!PyArg_ParseTuple(args,(char *)"iiii:glutVideoPan",&arg1,&arg2,&arg3,&arg4)) return NULL;
    {
        glutVideoPan(arg1,arg2,arg3,arg4);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutInitDisplayString(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    char *arg1 ;
    
    if(!PyArg_ParseTuple(args,(char *)"s:glutInitDisplayString",&arg1)) return NULL;
    {
        glutInitDisplayString((char const *)arg1);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutBitmapLength(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    void *arg1 ;
    unsigned char *arg2 ;
    int result;
    PyObject *temp_2 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glutBitmapLength",&obj0,&obj1)) return NULL;
    {
        arg1 = _PyInt_AsFont(obj0);
        if (PyErr_Occurred()) return NULL;
    }
    {
        arg2 = _PyObject_AsUnsignedCharArray(obj1, &temp_2, NULL); 
    }
    {
        result = (int)glutBitmapLength(arg1,(unsigned char const *)arg2);
        if (GLErrOccurred()) return NULL; 
    }
    resultobj = PyInt_FromLong((long)result);
    {
        _PyObject_AsArray_Cleanup(arg2, temp_2); 
    }
    return resultobj;
}


static PyObject *_wrap_glutStrokeLength(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    void *arg1 ;
    unsigned char *arg2 ;
    int result;
    PyObject *temp_2 ;
    PyObject * obj0  = 0 ;
    PyObject * obj1  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"OO:glutStrokeLength",&obj0,&obj1)) return NULL;
    {
        arg1 = _PyInt_AsFont(obj0);
        if (PyErr_Occurred()) return NULL;
    }
    {
        arg2 = _PyObject_AsUnsignedCharArray(obj1, &temp_2, NULL); 
    }
    {
        result = (int)glutStrokeLength(arg1,(unsigned char const *)arg2);
        if (GLErrOccurred()) return NULL; 
    }
    resultobj = PyInt_FromLong((long)result);
    {
        _PyObject_AsArray_Cleanup(arg2, temp_2); 
    }
    return resultobj;
}


static PyObject *_wrap_glutReportErrors(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    
    if(!PyArg_ParseTuple(args,(char *)":glutReportErrors")) return NULL;
    {
        glutReportErrors();
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutPostWindowRedisplay(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    int arg1 ;
    
    if(!PyArg_ParseTuple(args,(char *)"i:glutPostWindowRedisplay",&arg1)) return NULL;
    {
        glutPostWindowRedisplay(arg1);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutPostWindowOverlayRedisplay(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    int arg1 ;
    
    if(!PyArg_ParseTuple(args,(char *)"i:glutPostWindowOverlayRedisplay",&arg1)) return NULL;
    {
        glutPostWindowOverlayRedisplay(arg1);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutIgnoreKeyRepeat(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    int arg1 ;
    
    if(!PyArg_ParseTuple(args,(char *)"i:glutIgnoreKeyRepeat",&arg1)) return NULL;
    {
        glutIgnoreKeyRepeat(arg1);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutSetKeyRepeat(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    int arg1 ;
    
    if(!PyArg_ParseTuple(args,(char *)"i:glutSetKeyRepeat",&arg1)) return NULL;
    {
        glutSetKeyRepeat(arg1);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutForceJoystickFunc(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    
    if(!PyArg_ParseTuple(args,(char *)":glutForceJoystickFunc")) return NULL;
    {
        glutForceJoystickFunc();
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutGameModeString(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    char *arg1 ;
    
    if(!PyArg_ParseTuple(args,(char *)"s:glutGameModeString",&arg1)) return NULL;
    {
        glutGameModeString((char const *)arg1);
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutEnterGameMode(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    int result;
    
    if(!PyArg_ParseTuple(args,(char *)":glutEnterGameMode")) return NULL;
    {
        result = (int)glutEnterGameMode();
        if (GLErrOccurred()) return NULL; 
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
}


static PyObject *_wrap_glutLeaveGameMode(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    
    if(!PyArg_ParseTuple(args,(char *)":glutLeaveGameMode")) return NULL;
    {
        glutLeaveGameMode();
        if (GLErrOccurred()) return NULL; 
    }
    Py_INCREF(Py_None); resultobj = Py_None;
    return resultobj;
}


static PyObject *_wrap_glutGameModeGet(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    GLenum arg1 ;
    int result;
    PyObject * obj0  = 0 ;
    
    if(!PyArg_ParseTuple(args,(char *)"O:glutGameModeGet",&obj0)) return NULL;
    arg1 = (GLenum) PyInt_AsLong(obj0);
    if (PyErr_Occurred()) return NULL;
    {
        result = (int)glutGameModeGet(arg1);
        if (GLErrOccurred()) return NULL; 
    }
    resultobj = PyInt_FromLong((long)result);
    return resultobj;
}


static PyObject *_wrap___info(PyObject *self, PyObject *args) {
    PyObject *resultobj;
    PyObject *result;
    
    if(!PyArg_ParseTuple(args,(char *)":__info")) return NULL;
    {
        result = (PyObject *)__info();
        if (GLErrOccurred()) return NULL; 
    }
    {
        resultobj= result;
    }
    return resultobj;
}


static PyMethodDef SwigMethods[] = {
	 { (char *)"glutInit", _wrap_glutInit, METH_VARARGS , _doc_glutInit},
	 { (char *)"glutInitDisplayMode", _wrap_glutInitDisplayMode, METH_VARARGS , _doc_glutInitDisplayMode},
	 { (char *)"glutInitWindowPosition", _wrap_glutInitWindowPosition, METH_VARARGS , _doc_glutInitWindowPosition},
	 { (char *)"glutInitWindowSize", _wrap_glutInitWindowSize, METH_VARARGS , _doc_glutInitWindowSize},
	 { (char *)"glutMainLoop", _wrap_glutMainLoop, METH_VARARGS , _doc_glutMainLoop},
	 { (char *)"glutDisplayFunc", _wrap_glutDisplayFunc, METH_VARARGS , _doc_glutDisplayFunc},
	 { (char *)"glutReshapeFunc", _wrap_glutReshapeFunc, METH_VARARGS , _doc_glutReshapeFunc},
	 { (char *)"glutKeyboardFunc", _wrap_glutKeyboardFunc, METH_VARARGS , _doc_glutKeyboardFunc},
	 { (char *)"glutMouseFunc", _wrap_glutMouseFunc, METH_VARARGS , _doc_glutMouseFunc},
	 { (char *)"glutMotionFunc", _wrap_glutMotionFunc, METH_VARARGS , _doc_glutMotionFunc},
	 { (char *)"glutPassiveMotionFunc", _wrap_glutPassiveMotionFunc, METH_VARARGS , _doc_glutPassiveMotionFunc},
	 { (char *)"glutEntryFunc", _wrap_glutEntryFunc, METH_VARARGS , _doc_glutEntryFunc},
	 { (char *)"glutVisibilityFunc", _wrap_glutVisibilityFunc, METH_VARARGS , _doc_glutVisibilityFunc},
	 { (char *)"glutSpecialFunc", _wrap_glutSpecialFunc, METH_VARARGS , _doc_glutSpecialFunc},
	 { (char *)"glutSpaceballMotionFunc", _wrap_glutSpaceballMotionFunc, METH_VARARGS , _doc_glutSpaceballMotionFunc},
	 { (char *)"glutSpaceballRotateFunc", _wrap_glutSpaceballRotateFunc, METH_VARARGS , _doc_glutSpaceballRotateFunc},
	 { (char *)"glutSpaceballButtonFunc", _wrap_glutSpaceballButtonFunc, METH_VARARGS , _doc_glutSpaceballButtonFunc},
	 { (char *)"glutButtonBoxFunc", _wrap_glutButtonBoxFunc, METH_VARARGS , _doc_glutButtonBoxFunc},
	 { (char *)"glutDialsFunc", _wrap_glutDialsFunc, METH_VARARGS , _doc_glutDialsFunc},
	 { (char *)"glutTabletMotionFunc", _wrap_glutTabletMotionFunc, METH_VARARGS , _doc_glutTabletMotionFunc},
	 { (char *)"glutTabletButtonFunc", _wrap_glutTabletButtonFunc, METH_VARARGS , _doc_glutTabletButtonFunc},
	 { (char *)"glutSpecialUpFunc", _wrap_glutSpecialUpFunc, METH_VARARGS , _doc_glutSpecialUpFunc},
	 { (char *)"glutKeyboardUpFunc", _wrap_glutKeyboardUpFunc, METH_VARARGS , _doc_glutKeyboardUpFunc},
	 { (char *)"glutJoystickFunc", _wrap_glutJoystickFunc, METH_VARARGS , _doc_glutJoystickFunc},
	 { (char *)"glutOverlayDisplayFunc", _wrap_glutOverlayDisplayFunc, METH_VARARGS , _doc_glutOverlayDisplayFunc},
	 { (char *)"glutIdleFunc", _wrap_glutIdleFunc, METH_VARARGS , _doc_glutIdleFunc},
	 { (char *)"glutTimerFunc", _wrap_glutTimerFunc, METH_VARARGS , _doc_glutTimerFunc},
	 { (char *)"glutMenuStateFunc", _wrap_glutMenuStateFunc, METH_VARARGS , _doc_glutMenuStateFunc},
	 { (char *)"glutMenuStatusFunc", _wrap_glutMenuStatusFunc, METH_VARARGS , _doc_glutMenuStatusFunc},
	 { (char *)"glutWindowStatusFunc", _wrap_glutWindowStatusFunc, METH_VARARGS , _doc_glutWindowStatusFunc},
	 { (char *)"glutCreateWindow", _wrap_glutCreateWindow, METH_VARARGS , _doc_glutCreateWindow},
	 { (char *)"glutCreateSubWindow", _wrap_glutCreateSubWindow, METH_VARARGS , _doc_glutCreateSubWindow},
	 { (char *)"glutDestroyWindow", _wrap_glutDestroyWindow, METH_VARARGS , _doc_glutDestroyWindow},
	 { (char *)"glutPostRedisplay", _wrap_glutPostRedisplay, METH_VARARGS , _doc_glutPostRedisplay},
	 { (char *)"glutSwapBuffers", _wrap_glutSwapBuffers, METH_VARARGS , _doc_glutSwapBuffers},
	 { (char *)"glutGetWindow", _wrap_glutGetWindow, METH_VARARGS , _doc_glutGetWindow},
	 { (char *)"glutSetWindow", _wrap_glutSetWindow, METH_VARARGS , _doc_glutSetWindow},
	 { (char *)"glutSetWindowTitle", _wrap_glutSetWindowTitle, METH_VARARGS , _doc_glutSetWindowTitle},
	 { (char *)"glutSetIconTitle", _wrap_glutSetIconTitle, METH_VARARGS , _doc_glutSetIconTitle},
	 { (char *)"glutPositionWindow", _wrap_glutPositionWindow, METH_VARARGS , _doc_glutPositionWindow},
	 { (char *)"glutReshapeWindow", _wrap_glutReshapeWindow, METH_VARARGS , _doc_glutReshapeWindow},
	 { (char *)"glutPopWindow", _wrap_glutPopWindow, METH_VARARGS , _doc_glutPopWindow},
	 { (char *)"glutPushWindow", _wrap_glutPushWindow, METH_VARARGS , _doc_glutPushWindow},
	 { (char *)"glutIconifyWindow", _wrap_glutIconifyWindow, METH_VARARGS , _doc_glutIconifyWindow},
	 { (char *)"glutShowWindow", _wrap_glutShowWindow, METH_VARARGS , _doc_glutShowWindow},
	 { (char *)"glutHideWindow", _wrap_glutHideWindow, METH_VARARGS , _doc_glutHideWindow},
	 { (char *)"glutCreateMenu", _wrap_glutCreateMenu, METH_VARARGS , _doc_glutCreateMenu},
	 { (char *)"glutDestroyMenu", _wrap_glutDestroyMenu, METH_VARARGS , _doc_glutDestroyMenu},
	 { (char *)"glutGetMenu", _wrap_glutGetMenu, METH_VARARGS , _doc_glutGetMenu},
	 { (char *)"glutSetMenu", _wrap_glutSetMenu, METH_VARARGS , _doc_glutSetMenu},
	 { (char *)"glutAddMenuEntry", _wrap_glutAddMenuEntry, METH_VARARGS , _doc_glutAddMenuEntry},
	 { (char *)"glutAddSubMenu", _wrap_glutAddSubMenu, METH_VARARGS , _doc_glutAddSubMenu},
	 { (char *)"glutChangeToMenuEntry", _wrap_glutChangeToMenuEntry, METH_VARARGS , _doc_glutChangeToMenuEntry},
	 { (char *)"glutChangeToSubMenu", _wrap_glutChangeToSubMenu, METH_VARARGS , _doc_glutChangeToSubMenu},
	 { (char *)"glutRemoveMenuItem", _wrap_glutRemoveMenuItem, METH_VARARGS , _doc_glutRemoveMenuItem},
	 { (char *)"glutAttachMenu", _wrap_glutAttachMenu, METH_VARARGS , _doc_glutAttachMenu},
	 { (char *)"glutDetachMenu", _wrap_glutDetachMenu, METH_VARARGS , _doc_glutDetachMenu},
	 { (char *)"glutSetColor", _wrap_glutSetColor, METH_VARARGS , _doc_glutSetColor},
	 { (char *)"glutGetColor", _wrap_glutGetColor, METH_VARARGS , _doc_glutGetColor},
	 { (char *)"glutCopyColormap", _wrap_glutCopyColormap, METH_VARARGS , _doc_glutCopyColormap},
	 { (char *)"glutGet", _wrap_glutGet, METH_VARARGS , _doc_glutGet},
	 { (char *)"glutDeviceGet", _wrap_glutDeviceGet, METH_VARARGS , _doc_glutDeviceGet},
	 { (char *)"glutBitmapCharacter", _wrap_glutBitmapCharacter, METH_VARARGS , _doc_glutBitmapCharacter},
	 { (char *)"glutBitmapWidth", _wrap_glutBitmapWidth, METH_VARARGS , _doc_glutBitmapWidth},
	 { (char *)"glutStrokeCharacter", _wrap_glutStrokeCharacter, METH_VARARGS , _doc_glutStrokeCharacter},
	 { (char *)"glutStrokeWidth", _wrap_glutStrokeWidth, METH_VARARGS , _doc_glutStrokeWidth},
	 { (char *)"glutWireSphere", _wrap_glutWireSphere, METH_VARARGS , _doc_glutWireSphere},
	 { (char *)"glutSolidSphere", _wrap_glutSolidSphere, METH_VARARGS , _doc_glutSolidSphere},
	 { (char *)"glutWireCone", _wrap_glutWireCone, METH_VARARGS , _doc_glutWireCone},
	 { (char *)"glutSolidCone", _wrap_glutSolidCone, METH_VARARGS , _doc_glutSolidCone},
	 { (char *)"glutWireCube", _wrap_glutWireCube, METH_VARARGS , _doc_glutWireCube},
	 { (char *)"glutSolidCube", _wrap_glutSolidCube, METH_VARARGS , _doc_glutSolidCube},
	 { (char *)"glutWireTorus", _wrap_glutWireTorus, METH_VARARGS , _doc_glutWireTorus},
	 { (char *)"glutSolidTorus", _wrap_glutSolidTorus, METH_VARARGS , _doc_glutSolidTorus},
	 { (char *)"glutWireDodecahedron", _wrap_glutWireDodecahedron, METH_VARARGS , _doc_glutWireDodecahedron},
	 { (char *)"glutSolidDodecahedron", _wrap_glutSolidDodecahedron, METH_VARARGS , _doc_glutSolidDodecahedron},
	 { (char *)"glutWireTeapot", _wrap_glutWireTeapot, METH_VARARGS , _doc_glutWireTeapot},
	 { (char *)"glutSolidTeapot", _wrap_glutSolidTeapot, METH_VARARGS , _doc_glutSolidTeapot},
	 { (char *)"glutWireOctahedron", _wrap_glutWireOctahedron, METH_VARARGS , _doc_glutWireOctahedron},
	 { (char *)"glutSolidOctahedron", _wrap_glutSolidOctahedron, METH_VARARGS , _doc_glutSolidOctahedron},
	 { (char *)"glutWireTetrahedron", _wrap_glutWireTetrahedron, METH_VARARGS , _doc_glutWireTetrahedron},
	 { (char *)"glutSolidTetrahedron", _wrap_glutSolidTetrahedron, METH_VARARGS , _doc_glutSolidTetrahedron},
	 { (char *)"glutWireIcosahedron", _wrap_glutWireIcosahedron, METH_VARARGS , _doc_glutWireIcosahedron},
	 { (char *)"glutSolidIcosahedron", _wrap_glutSolidIcosahedron, METH_VARARGS , _doc_glutSolidIcosahedron},
	 { (char *)"glutExtensionSupported", _wrap_glutExtensionSupported, METH_VARARGS , _doc_glutExtensionSupported},
	 { (char *)"glutFullScreen", _wrap_glutFullScreen, METH_VARARGS , _doc_glutFullScreen},
	 { (char *)"glutSetCursor", _wrap_glutSetCursor, METH_VARARGS , _doc_glutSetCursor},
	 { (char *)"glutEstablishOverlay", _wrap_glutEstablishOverlay, METH_VARARGS , _doc_glutEstablishOverlay},
	 { (char *)"glutRemoveOverlay", _wrap_glutRemoveOverlay, METH_VARARGS , _doc_glutRemoveOverlay},
	 { (char *)"glutUseLayer", _wrap_glutUseLayer, METH_VARARGS , _doc_glutUseLayer},
	 { (char *)"glutPostOverlayRedisplay", _wrap_glutPostOverlayRedisplay, METH_VARARGS , _doc_glutPostOverlayRedisplay},
	 { (char *)"glutShowOverlay", _wrap_glutShowOverlay, METH_VARARGS , _doc_glutShowOverlay},
	 { (char *)"glutHideOverlay", _wrap_glutHideOverlay, METH_VARARGS , _doc_glutHideOverlay},
	 { (char *)"glutGetModifiers", _wrap_glutGetModifiers, METH_VARARGS , _doc_glutGetModifiers},
	 { (char *)"glutLayerGet", _wrap_glutLayerGet, METH_VARARGS , _doc_glutLayerGet},
	 { (char *)"glutWarpPointer", _wrap_glutWarpPointer, METH_VARARGS , _doc_glutWarpPointer},
	 { (char *)"glutVideoResizeGet", _wrap_glutVideoResizeGet, METH_VARARGS , _doc_glutVideoResizeGet},
	 { (char *)"glutSetupVideoResizing", _wrap_glutSetupVideoResizing, METH_VARARGS , _doc_glutSetupVideoResizing},
	 { (char *)"glutStopVideoResizing", _wrap_glutStopVideoResizing, METH_VARARGS , _doc_glutStopVideoResizing},
	 { (char *)"glutVideoResize", _wrap_glutVideoResize, METH_VARARGS , _doc_glutVideoResize},
	 { (char *)"glutVideoPan", _wrap_glutVideoPan, METH_VARARGS , _doc_glutVideoPan},
	 { (char *)"glutInitDisplayString", _wrap_glutInitDisplayString, METH_VARARGS , _doc_glutInitDisplayString},
	 { (char *)"glutBitmapLength", _wrap_glutBitmapLength, METH_VARARGS , _doc_glutBitmapLength},
	 { (char *)"glutStrokeLength", _wrap_glutStrokeLength, METH_VARARGS , _doc_glutStrokeLength},
	 { (char *)"glutReportErrors", _wrap_glutReportErrors, METH_VARARGS , _doc_glutReportErrors},
	 { (char *)"glutPostWindowRedisplay", _wrap_glutPostWindowRedisplay, METH_VARARGS , _doc_glutPostWindowRedisplay},
	 { (char *)"glutPostWindowOverlayRedisplay", _wrap_glutPostWindowOverlayRedisplay, METH_VARARGS , _doc_glutPostWindowOverlayRedisplay},
	 { (char *)"glutIgnoreKeyRepeat", _wrap_glutIgnoreKeyRepeat, METH_VARARGS , _doc_glutIgnoreKeyRepeat},
	 { (char *)"glutSetKeyRepeat", _wrap_glutSetKeyRepeat, METH_VARARGS , _doc_glutSetKeyRepeat},
	 { (char *)"glutForceJoystickFunc", _wrap_glutForceJoystickFunc, METH_VARARGS , _doc_glutForceJoystickFunc},
	 { (char *)"glutGameModeString", _wrap_glutGameModeString, METH_VARARGS , _doc_glutGameModeString},
	 { (char *)"glutEnterGameMode", _wrap_glutEnterGameMode, METH_VARARGS , _doc_glutEnterGameMode},
	 { (char *)"glutLeaveGameMode", _wrap_glutLeaveGameMode, METH_VARARGS , _doc_glutLeaveGameMode},
	 { (char *)"glutGameModeGet", _wrap_glutGameModeGet, METH_VARARGS , _doc_glutGameModeGet},
	 { (char *)"__info", _wrap___info, METH_VARARGS },
	 { NULL, NULL }
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */


static swig_type_info *swig_types_initial[] = {
0
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */

static swig_const_info swig_const_table[] = {
{ SWIG_PY_STRING,  (char*)"__version__", 0, 0, (void *)"1.49", 0},
{ SWIG_PY_STRING,  (char*)"__date__", 0, 0, (void *)"2003/10/19 04:04:12", 0},
{ SWIG_PY_INT,     (char *)"__api_version__", (long) 13, 0, 0, 0},
{ SWIG_PY_STRING,  (char*)"__author__", 0, 0, (void *)"Tarn Weisner Burton <twburton@users.sourceforge.net>\nMike C. Fletcher <mcfletch@users.sourceforge.net>", 0},
{ SWIG_PY_STRING,  (char*)"__credits__", 0, 0, (void *)"The GLUT module of PyOpenGL is based on PyGLUT by Andrew Cox.", 0},
{ SWIG_PY_STRING,  (char*)"__doc__", 0, 0, (void *)"The module provides an interface to the GLUT library.\n\nDocumentation:\n    Man Pages:  http://pyopengl.sourceforge.net/documentation/ref/glut.html\n    GLUT Homepage:  http://reality.sgi.com/mjk/glut3/glut3.html\n    OpenGL.org:  http://www.opengl.org/developers/documentation/glut.html", 0},
{ SWIG_PY_INT,     (char *)"GLUT_XLIB_IMPLEMENTATION", (long) 13, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_API_VERSION", (long) 3, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_RGB", (long) 0, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_RGBA", (long) 0, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_INDEX", (long) 1, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_SINGLE", (long) 0, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_DOUBLE", (long) 2, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_ACCUM", (long) 4, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_ALPHA", (long) 8, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_DEPTH", (long) 16, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_STENCIL", (long) 32, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_LEFT_BUTTON", (long) 0, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_MIDDLE_BUTTON", (long) 1, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_RIGHT_BUTTON", (long) 2, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_DOWN", (long) 0, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_UP", (long) 1, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_LEFT", (long) 0, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_ENTERED", (long) 1, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_MENU_NOT_IN_USE", (long) 0, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_MENU_IN_USE", (long) 1, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_NOT_VISIBLE", (long) 0, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_VISIBLE", (long) 1, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_HIDDEN", (long) 0, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_FULLY_RETAINED", (long) 1, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_PARTIALLY_RETAINED", (long) 2, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_FULLY_COVERED", (long) 3, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_RED", (long) 0, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_GREEN", (long) 1, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_BLUE", (long) 2, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_STROKE_ROMAN", (long) 0, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_STROKE_MONO_ROMAN", (long) 1, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_BITMAP_9_BY_15", (long) 2, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_BITMAP_8_BY_13", (long) 3, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_BITMAP_TIMES_ROMAN_10", (long) 4, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_BITMAP_TIMES_ROMAN_24", (long) 5, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_WINDOW_X", (long) 100, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_WINDOW_Y", (long) 101, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_WINDOW_WIDTH", (long) 102, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_WINDOW_HEIGHT", (long) 103, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_WINDOW_BUFFER_SIZE", (long) 104, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_WINDOW_STENCIL_SIZE", (long) 105, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_WINDOW_DEPTH_SIZE", (long) 106, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_WINDOW_RED_SIZE", (long) 107, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_WINDOW_GREEN_SIZE", (long) 108, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_WINDOW_BLUE_SIZE", (long) 109, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_WINDOW_ALPHA_SIZE", (long) 110, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_WINDOW_ACCUM_RED_SIZE", (long) 111, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_WINDOW_ACCUM_GREEN_SIZE", (long) 112, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_WINDOW_ACCUM_BLUE_SIZE", (long) 113, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_WINDOW_ACCUM_ALPHA_SIZE", (long) 114, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_WINDOW_DOUBLEBUFFER", (long) 115, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_WINDOW_RGBA", (long) 116, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_WINDOW_PARENT", (long) 117, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_WINDOW_NUM_CHILDREN", (long) 118, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_WINDOW_COLORMAP_SIZE", (long) 119, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_SCREEN_WIDTH", (long) 200, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_SCREEN_HEIGHT", (long) 201, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_SCREEN_WIDTH_MM", (long) 202, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_SCREEN_HEIGHT_MM", (long) 203, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_MENU_NUM_ITEMS", (long) 300, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_DISPLAY_MODE_POSSIBLE", (long) 400, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_INIT_WINDOW_X", (long) 500, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_INIT_WINDOW_Y", (long) 501, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_INIT_WINDOW_WIDTH", (long) 502, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_INIT_WINDOW_HEIGHT", (long) 503, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_INIT_DISPLAY_MODE", (long) 504, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_MULTISAMPLE", (long) 128, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_STEREO", (long) 256, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_KEY_F1", (long) 1, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_KEY_F2", (long) 2, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_KEY_F3", (long) 3, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_KEY_F4", (long) 4, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_KEY_F5", (long) 5, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_KEY_F6", (long) 6, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_KEY_F7", (long) 7, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_KEY_F8", (long) 8, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_KEY_F9", (long) 9, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_KEY_F10", (long) 10, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_KEY_F11", (long) 11, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_KEY_F12", (long) 12, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_KEY_LEFT", (long) 100, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_KEY_UP", (long) 101, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_KEY_RIGHT", (long) 102, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_KEY_DOWN", (long) 103, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_KEY_PAGE_UP", (long) 104, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_KEY_PAGE_DOWN", (long) 105, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_KEY_HOME", (long) 106, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_KEY_END", (long) 107, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_KEY_INSERT", (long) 108, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_WINDOW_NUM_SAMPLES", (long) 120, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_WINDOW_STEREO", (long) 121, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_ELAPSED_TIME", (long) 700, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_HAS_KEYBOARD", (long) 600, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_HAS_MOUSE", (long) 601, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_HAS_SPACEBALL", (long) 602, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_HAS_DIAL_AND_BUTTON_BOX", (long) 603, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_HAS_TABLET", (long) 604, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_NUM_MOUSE_BUTTONS", (long) 605, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_NUM_SPACEBALL_BUTTONS", (long) 606, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_NUM_BUTTON_BOX_BUTTONS", (long) 607, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_NUM_DIALS", (long) 608, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_NUM_TABLET_BUTTONS", (long) 609, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_LUMINANCE", (long) 512, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_BITMAP_HELVETICA_10", (long) 6, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_BITMAP_HELVETICA_12", (long) 7, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_BITMAP_HELVETICA_18", (long) 8, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_WINDOW_CURSOR", (long) 122, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_OVERLAY_POSSIBLE", (long) 800, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_LAYER_IN_USE", (long) 801, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_HAS_OVERLAY", (long) 802, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_TRANSPARENT_INDEX", (long) 803, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_NORMAL_DAMAGED", (long) 804, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_OVERLAY_DAMAGED", (long) 805, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_NORMAL", (long) 0, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_OVERLAY", (long) 1, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_ACTIVE_SHIFT", (long) 1, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_ACTIVE_CTRL", (long) 2, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_ACTIVE_ALT", (long) 4, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_CURSOR_RIGHT_ARROW", (long) 0, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_CURSOR_LEFT_ARROW", (long) 1, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_CURSOR_INFO", (long) 2, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_CURSOR_DESTROY", (long) 3, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_CURSOR_HELP", (long) 4, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_CURSOR_CYCLE", (long) 5, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_CURSOR_SPRAY", (long) 6, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_CURSOR_WAIT", (long) 7, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_CURSOR_TEXT", (long) 8, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_CURSOR_CROSSHAIR", (long) 9, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_CURSOR_UP_DOWN", (long) 10, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_CURSOR_LEFT_RIGHT", (long) 11, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_CURSOR_TOP_SIDE", (long) 12, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_CURSOR_BOTTOM_SIDE", (long) 13, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_CURSOR_LEFT_SIDE", (long) 14, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_CURSOR_RIGHT_SIDE", (long) 15, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_CURSOR_TOP_LEFT_CORNER", (long) 16, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_CURSOR_TOP_RIGHT_CORNER", (long) 17, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_CURSOR_BOTTOM_RIGHT_CORNER", (long) 18, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_CURSOR_BOTTOM_LEFT_CORNER", (long) 19, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_CURSOR_INHERIT", (long) 100, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_CURSOR_NONE", (long) 101, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_CURSOR_FULL_CROSSHAIR", (long) 102, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_VIDEO_RESIZE_POSSIBLE", (long) 900, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_VIDEO_RESIZE_IN_USE", (long) 901, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_VIDEO_RESIZE_X_DELTA", (long) 902, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_VIDEO_RESIZE_Y_DELTA", (long) 903, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_VIDEO_RESIZE_WIDTH_DELTA", (long) 904, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_VIDEO_RESIZE_HEIGHT_DELTA", (long) 905, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_VIDEO_RESIZE_X", (long) 906, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_VIDEO_RESIZE_Y", (long) 907, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_VIDEO_RESIZE_WIDTH", (long) 908, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_VIDEO_RESIZE_HEIGHT", (long) 909, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_WINDOW_FORMAT_ID", (long) 123, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_DEVICE_IGNORE_KEY_REPEAT", (long) 610, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_DEVICE_KEY_REPEAT", (long) 611, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_HAS_JOYSTICK", (long) 612, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_OWNS_JOYSTICK", (long) 613, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_JOYSTICK_BUTTONS", (long) 614, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_JOYSTICK_AXES", (long) 615, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_JOYSTICK_POLL_RATE", (long) 616, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_KEY_REPEAT_OFF", (long) 0, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_KEY_REPEAT_ON", (long) 1, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_KEY_REPEAT_DEFAULT", (long) 2, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_JOYSTICK_BUTTON_A", (long) 1, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_JOYSTICK_BUTTON_B", (long) 2, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_JOYSTICK_BUTTON_C", (long) 4, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_JOYSTICK_BUTTON_D", (long) 8, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_GAME_MODE_ACTIVE", (long) 0, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_GAME_MODE_POSSIBLE", (long) 1, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_GAME_MODE_WIDTH", (long) 2, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_GAME_MODE_HEIGHT", (long) 3, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_GAME_MODE_PIXEL_DEPTH", (long) 4, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_GAME_MODE_REFRESH_RATE", (long) 5, 0, 0, 0},
{ SWIG_PY_INT,     (char *)"GLUT_GAME_MODE_DISPLAY_CHANGED", (long) 6, 0, 0, 0},
{0}};

#ifdef __cplusplus
}
#endif

#ifdef __cplusplus
extern "C"
#endif
SWIGEXPORT(void) SWIG_init(void) {
    static PyObject *SWIG_globals = 0; 
    static int       typeinit = 0;
    PyObject *m, *d;
    int       i;
    if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
    m = Py_InitModule((char *) SWIG_name, SwigMethods);
    d = PyModule_GetDict(m);
    
    if (!typeinit) {
        for (i = 0; swig_types_initial[i]; i++) {
            swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
        }
        typeinit = 1;
    }
    SWIG_InstallConstants(d,swig_const_table);
    
    
    #ifdef NUMERIC
    PyArray_API = NULL;
    import_array();
    init_util();
    PyErr_Clear();
    #endif
    
    
    {
        PyObject *util = PyImport_ImportModule("OpenGL.GL.GL__init___");
        if (util)
        {
            PyObject *api_object = PyDict_GetItemString(PyModule_GetDict(util), "_util_API");
            if (PyCObject_Check(api_object)) _util_API = (util_API*)PyCObject_AsVoidPtr(api_object);
        }
    }
    
    
    windows = PyDict_New();
    menus = PyDict_New();
    
}

