/*
 * Module code.
 *
 * Generated by SIP 4.19.12
 *
 * Copyright (c) 2018 Riverbank Computing Limited <info@riverbankcomputing.com>
 * 
 * This file is part of PyQt4.
 * 
 * This file may be used under the terms of the GNU General Public License
 * version 3.0 as published by the Free Software Foundation and appearing in
 * the file LICENSE included in the packaging of this file.  Please review the
 * following information to ensure the GNU General Public License version 3.0
 * requirements will be met: http://www.gnu.org/copyleft/gpl.html.
 * 
 * If you do not wish to use this file under the terms of the GPL version 3.0
 * then you may purchase a commercial license.  For more information contact
 * info@riverbankcomputing.com.
 * 
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 */

#include "sipAPIQtOpenGL.h"

#line 29 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qobject.sip"
#include <qobject.h>
#line 29 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qgl.sip"
#include <qgl.h>
#line 32 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 70 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qgl.sip"
#include <qgl.h>
#line 35 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 225 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qgl.sip"
#include <qgl.h>
#line 38 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 29 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qglshaderprogram.sip"
#include <qglshaderprogram.h>
#line 41 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qfont.sip"
#include <qfont.h>
#line 44 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qpalette.sip"
#include <qpalette.h>
#line 47 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 265 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 50 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 53 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 647 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qevent.sip"
#include <qevent.h>
#line 56 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 59 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 607 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qevent.sip"
#include <qevent.h>
#line 62 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 596 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qevent.sip"
#include <qevent.h>
#line 65 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 739 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qevent.sip"
#include <qevent.h>
#line 68 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 792 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qevent.sip"
#include <qevent.h>
#line 71 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 765 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qevent.sip"
#include <qevent.h>
#line 74 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 781 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qevent.sip"
#include <qevent.h>
#line 77 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 854 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qevent.sip"
#include <qevent.h>
#line 80 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 403 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qevent.sip"
#include <qevent.h>
#line 83 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 618 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qevent.sip"
#include <qevent.h>
#line 86 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 574 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qevent.sip"
#include <qevent.h>
#line 89 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 561 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qevent.sip"
#include <qevent.h>
#line 92 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 548 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qevent.sip"
#include <qevent.h>
#line 95 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 524 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qevent.sip"
#include <qevent.h>
#line 98 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 505 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qevent.sip"
#include <qevent.h>
#line 101 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 474 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qevent.sip"
#include <qevent.h>
#line 104 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 347 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qevent.sip"
#include <qevent.h>
#line 107 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 252 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qevent.sip"
#include <qevent.h>
#line 110 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qsize.sip"
#include <qsize.h>
#line 113 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 52 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qpaintengine.sip"
#include <qpaintengine.h>
#line 116 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qpaintdevice.sip"
#include <qpaintdevice.h>
#line 119 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 351 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 122 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 368 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 125 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qgl.sip"
#include <qgl.h>
#line 128 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 70 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qgl.sip"
#include <qgl.h>
#line 131 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 225 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qgl.sip"
#include <qgl.h>
#line 134 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 29 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qglbuffer.sip"
#include <qglbuffer.h>
#line 137 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qglcolormap.sip"
#include <qglcolormap.h>
#line 140 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 117 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qglframebufferobject.sip"
#include <qglframebufferobject.h>
#line 143 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 29 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qglshaderprogram.sip"
#include <qglshaderprogram.h>
#line 146 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

/* Define the strings used by this module. */
const char sipStrings_QtOpenGL[] = {
    'Q', 'G', 'L', 'F', 'r', 'a', 'm', 'e', 'b', 'u', 'f', 'f', 'e', 'r', 'O', 'b', 'j', 'e', 'c', 't', ':', ':', 'A', 't', 't', 'a', 'c', 'h', 'm', 'e', 'n', 't', 0,
    'O', 'p', 'e', 'n', 'G', 'L', '_', 'E', 'S', '_', 'C', 'o', 'm', 'm', 'o', 'n', 'L', 'i', 't', 'e', '_', 'V', 'e', 'r', 's', 'i', 'o', 'n', '_', '1', '_', '1', 0,
    'O', 'p', 'e', 'n', 'G', 'L', '_', 'E', 'S', '_', 'C', 'o', 'm', 'm', 'o', 'n', 'L', 'i', 't', 'e', '_', 'V', 'e', 'r', 's', 'i', 'o', 'n', '_', '1', '_', '0', 0,
    'Q', 'G', 'L', 'F', 'o', 'r', 'm', 'a', 't', ':', ':', 'O', 'p', 'e', 'n', 'G', 'L', 'C', 'o', 'n', 't', 'e', 'x', 't', 'P', 'r', 'o', 'f', 'i', 'l', 'e', 0,
    'Q', 'G', 'L', 'F', 'o', 'r', 'm', 'a', 't', ':', ':', 'O', 'p', 'e', 'n', 'G', 'L', 'V', 'e', 'r', 's', 'i', 'o', 'n', 'F', 'l', 'a', 'g', 's', 0,
    's', 'e', 't', 'G', 'e', 'o', 'm', 'e', 't', 'r', 'y', 'O', 'u', 't', 'p', 'u', 't', 'V', 'e', 'r', 't', 'e', 'x', 'C', 'o', 'u', 'n', 't', 0,
    'P', 'r', 'e', 'm', 'u', 'l', 't', 'i', 'p', 'l', 'i', 'e', 'd', 'A', 'l', 'p', 'h', 'a', 'B', 'i', 'n', 'd', 'O', 'p', 't', 'i', 'o', 'n', 0,
    'O', 'p', 'e', 'n', 'G', 'L', '_', 'E', 'S', '_', 'C', 'o', 'm', 'm', 'o', 'n', '_', 'V', 'e', 'r', 's', 'i', 'o', 'n', '_', '1', '_', '1', 0,
    'O', 'p', 'e', 'n', 'G', 'L', '_', 'E', 'S', '_', 'C', 'o', 'm', 'm', 'o', 'n', '_', 'V', 'e', 'r', 's', 'i', 'o', 'n', '_', '1', '_', '0', 0,
    'Q', 'G', 'L', 'F', 'o', 'r', 'm', 'a', 't', ':', ':', 'O', 'p', 'e', 'n', 'G', 'L', 'V', 'e', 'r', 's', 'i', 'o', 'n', 'F', 'l', 'a', 'g', 0,
    'P', 'y', 'Q', 't', '4', '.', 'Q', 't', 'C', 'o', 'r', 'e', '.', 'p', 'y', 'q', 't', 'W', 'r', 'a', 'p', 'p', 'e', 'r', 'T', 'y', 'p', 'e', 0,
    'h', 'a', 's', 'O', 'p', 'e', 'n', 'G', 'L', 'F', 'r', 'a', 'm', 'e', 'b', 'u', 'f', 'f', 'e', 'r', 'O', 'b', 'j', 'e', 'c', 't', 's', 0,
    'Q', 'G', 'L', 'F', 'r', 'a', 'm', 'e', 'b', 'u', 'f', 'f', 'e', 'r', 'O', 'b', 'j', 'e', 'c', 't', 'F', 'o', 'r', 'm', 'a', 't', 0,
    'g', 'e', 'o', 'm', 'e', 't', 'r', 'y', 'O', 'u', 't', 'p', 'u', 't', 'V', 'e', 'r', 't', 'e', 'x', 'C', 'o', 'u', 'n', 't', 0,
    'r', 'e', 'l', 'e', 'a', 's', 'e', 'F', 'r', 'o', 'm', 'D', 'y', 'n', 'a', 'm', 'i', 'c', 'T', 'e', 'x', 't', 'u', 'r', 'e', 0,
    'L', 'i', 'n', 'e', 'a', 'r', 'F', 'i', 'l', 't', 'e', 'r', 'i', 'n', 'g', 'B', 'i', 'n', 'd', 'O', 'p', 't', 'i', 'o', 'n', 0,
    'Q', 'G', 'L', 'S', 'h', 'a', 'd', 'e', 'r', ':', ':', 'S', 'h', 'a', 'd', 'e', 'r', 'T', 'y', 'p', 'e', 'B', 'i', 't', 0,
    's', 'e', 't', 'I', 'n', 't', 'e', 'r', 'n', 'a', 'l', 'T', 'e', 'x', 't', 'u', 'r', 'e', 'F', 'o', 'r', 'm', 'a', 't', 0,
    'h', 'a', 's', 'O', 'p', 'e', 'n', 'G', 'L', 'F', 'r', 'a', 'm', 'e', 'b', 'u', 'f', 'f', 'e', 'r', 'B', 'l', 'i', 't', 0,
    'g', 'e', 'n', 'e', 'r', 'a', 't', 'e', 'F', 'o', 'n', 't', 'D', 'i', 's', 'p', 'l', 'a', 'y', 'L', 'i', 's', 't', 's', 0,
    'h', 'a', 's', 'O', 'p', 'e', 'n', 'G', 'L', 'S', 'h', 'a', 'd', 'e', 'r', 'P', 'r', 'o', 'g', 'r', 'a', 'm', 's', 0,
    'a', 'd', 'd', 'S', 'h', 'a', 'd', 'e', 'r', 'F', 'r', 'o', 'm', 'S', 'o', 'u', 'r', 'c', 'e', 'F', 'i', 'l', 'e', 0,
    'a', 'd', 'd', 'S', 'h', 'a', 'd', 'e', 'r', 'F', 'r', 'o', 'm', 'S', 'o', 'u', 'r', 'c', 'e', 'C', 'o', 'd', 'e', 0,
    'Q', 'G', 'L', 'B', 'u', 'f', 'f', 'e', 'r', ':', ':', 'U', 's', 'a', 'g', 'e', 'P', 'a', 't', 't', 'e', 'r', 'n', 0,
    'Q', 'G', 'L', 'C', 'o', 'n', 't', 'e', 'x', 't', ':', ':', 'B', 'i', 'n', 'd', 'O', 'p', 't', 'i', 'o', 'n', 's', 0,
    'o', 'v', 'e', 'r', 'l', 'a', 'y', 'T', 'r', 'a', 'n', 's', 'p', 'a', 'r', 'e', 'n', 't', 'C', 'o', 'l', 'o', 'r', 0,
    's', 'e', 't', 'D', 'e', 'f', 'a', 'u', 'l', 't', 'O', 'v', 'e', 'r', 'l', 'a', 'y', 'F', 'o', 'r', 'm', 'a', 't', 0,
    's', 'e', 't', 'P', 'r', 'e', 'f', 'e', 'r', 'r', 'e', 'd', 'P', 'a', 'i', 'n', 't', 'E', 'n', 'g', 'i', 'n', 'e', 0,
    'g', 'e', 'n', 'e', 'r', 'a', 't', 'e', 'D', 'y', 'n', 'a', 'm', 'i', 'c', 'T', 'e', 'x', 't', 'u', 'r', 'e', 0,
    'Q', 'G', 'L', 'C', 'o', 'n', 't', 'e', 'x', 't', ':', ':', 'B', 'i', 'n', 'd', 'O', 'p', 't', 'i', 'o', 'n', 0,
    'w', 'i', 'n', 'd', 'o', 'w', 'A', 'c', 't', 'i', 'v', 'a', 't', 'i', 'o', 'n', 'C', 'h', 'a', 'n', 'g', 'e', 0,
    's', 'e', 't', 'G', 'e', 'o', 'm', 'e', 't', 'r', 'y', 'O', 'u', 't', 'p', 'u', 't', 'T', 'y', 'p', 'e', 0,
    'd', 'i', 's', 'a', 'b', 'l', 'e', 'A', 't', 't', 'r', 'i', 'b', 'u', 't', 'e', 'A', 'r', 'r', 'a', 'y', 0,
    'b', 'i', 'n', 'd', 'A', 't', 't', 'r', 'i', 'b', 'u', 't', 'e', 'L', 'o', 'c', 'a', 't', 'i', 'o', 'n', 0,
    'Q', 'G', 'L', 'S', 'h', 'a', 'd', 'e', 'r', ':', ':', 'S', 'h', 'a', 'd', 'e', 'r', 'T', 'y', 'p', 'e', 0,
    'i', 'n', 't', 'e', 'r', 'n', 'a', 'l', 'T', 'e', 'x', 't', 'u', 'r', 'e', 'F', 'o', 'r', 'm', 'a', 't', 0,
    'O', 'p', 'e', 'n', 'G', 'L', '_', 'E', 'S', '_', 'V', 'e', 'r', 's', 'i', 'o', 'n', '_', '2', '_', '0', 0,
    'N', 'o', 'D', 'e', 'p', 'r', 'e', 'c', 'a', 't', 'e', 'd', 'F', 'u', 'n', 'c', 't', 'i', 'o', 'n', 's', 0,
    'm', 'o', 'u', 's', 'e', 'D', 'o', 'u', 'b', 'l', 'e', 'C', 'l', 'i', 'c', 'k', 'E', 'v', 'e', 'n', 't', 0,
    's', 'e', 't', 'G', 'e', 'o', 'm', 'e', 't', 'r', 'y', 'I', 'n', 'p', 'u', 't', 'T', 'y', 'p', 'e', 0,
    's', 'e', 't', 'U', 'n', 'i', 'f', 'o', 'r', 'm', 'V', 'a', 'l', 'u', 'e', 'A', 'r', 'r', 'a', 'y', 0,
    'e', 'n', 'a', 'b', 'l', 'e', 'A', 't', 't', 'r', 'i', 'b', 'u', 't', 'e', 'A', 'r', 'r', 'a', 'y', 0,
    'u', 'p', 'd', 'a', 't', 'e', 'D', 'y', 'n', 'a', 'm', 'i', 'c', 'T', 'e', 'x', 't', 'u', 'r', 'e', 0,
    'b', 'i', 'n', 'd', 'T', 'o', 'D', 'y', 'n', 'a', 'm', 'i', 'c', 'T', 'e', 'x', 't', 'u', 'r', 'e', 0,
    'C', 'o', 'm', 'b', 'i', 'n', 'e', 'd', 'D', 'e', 'p', 't', 'h', 'S', 't', 'e', 'n', 'c', 'i', 'l', 0,
    'Q', 'G', 'L', 'F', 'r', 'a', 'm', 'e', 'b', 'u', 'f', 'f', 'e', 'r', 'O', 'b', 'j', 'e', 'c', 't', 0,
    's', 'e', 't', 'T', 'e', 'x', 't', 'u', 'r', 'e', 'C', 'a', 'c', 'h', 'e', 'L', 'i', 'm', 'i', 't', 0,
    'C', 'o', 'm', 'p', 'a', 't', 'i', 'b', 'i', 'l', 'i', 't', 'y', 'P', 'r', 'o', 'f', 'i', 'l', 'e', 0,
    'd', 'e', 'f', 'a', 'u', 'l', 't', 'O', 'v', 'e', 'r', 'l', 'a', 'y', 'F', 'o', 'r', 'm', 'a', 't', 0,
    's', 'e', 't', 'S', 't', 'e', 'n', 'c', 'i', 'l', 'B', 'u', 'f', 'f', 'e', 'r', 'S', 'i', 'z', 'e', 0,
    'f', 'o', 'n', 't', 'D', 'i', 's', 'p', 'l', 'a', 'y', 'L', 'i', 's', 't', 'B', 'a', 's', 'e', 0,
    'i', 'n', 'i', 't', 'i', 'a', 'l', 'i', 'z', 'e', 'O', 'v', 'e', 'r', 'l', 'a', 'y', 'G', 'L', 0,
    'I', 'n', 'v', 'e', 'r', 't', 'e', 'd', 'Y', 'B', 'i', 'n', 'd', 'O', 'p', 't', 'i', 'o', 'n', 0,
    'O', 'p', 'e', 'n', 'G', 'L', '_', 'V', 'e', 'r', 's', 'i', 'o', 'n', '_', 'N', 'o', 'n', 'e', 0,
    'd', 'e', 'f', 'a', 'u', 'l', 't', 'B', 'u', 't', 't', 'o', 'n', 'N', 'u', 'm', 'b', 'e', 'r', 0,
    's', 'e', 't', 'A', 't', 't', 'r', 'i', 'b', 'u', 't', 'e', 'B', 'u', 'f', 'f', 'e', 'r', 0,
    'g', 'e', 'o', 'm', 'e', 't', 'r', 'y', 'O', 'u', 't', 'p', 'u', 't', 'T', 'y', 'p', 'e', 0,
    'm', 'a', 'k', 'e', 'O', 'v', 'e', 'r', 'l', 'a', 'y', 'C', 'u', 'r', 'r', 'e', 'n', 't', 0,
    'o', 'p', 'e', 'n', 'G', 'L', 'V', 'e', 'r', 's', 'i', 'o', 'n', 'F', 'l', 'a', 'g', 's', 0,
    's', 'e', 't', 'G', 'r', 'e', 'e', 'n', 'B', 'u', 'f', 'f', 'e', 'r', 'S', 'i', 'z', 'e', 0,
    's', 'e', 't', 'D', 'i', 'r', 'e', 'c', 't', 'R', 'e', 'n', 'd', 'e', 'r', 'i', 'n', 'g', 0,
    's', 'e', 't', 'A', 'l', 'p', 'h', 'a', 'B', 'u', 'f', 'f', 'e', 'r', 'S', 'i', 'z', 'e', 0,
    's', 'e', 't', 'A', 'c', 'c', 'u', 'm', 'B', 'u', 'f', 'f', 'e', 'r', 'S', 'i', 'z', 'e', 0,
    's', 'e', 't', 'D', 'e', 'p', 't', 'h', 'B', 'u', 'f', 'f', 'e', 'r', 'S', 'i', 'z', 'e', 0,
    'O', 'p', 'e', 'n', 'G', 'L', '_', 'V', 'e', 'r', 's', 'i', 'o', 'n', '_', '4', '_', '0', 0,
    'O', 'p', 'e', 'n', 'G', 'L', '_', 'V', 'e', 'r', 's', 'i', 'o', 'n', '_', '3', '_', '3', 0,
    'O', 'p', 'e', 'n', 'G', 'L', '_', 'V', 'e', 'r', 's', 'i', 'o', 'n', '_', '3', '_', '2', 0,
    'O', 'p', 'e', 'n', 'G', 'L', '_', 'V', 'e', 'r', 's', 'i', 'o', 'n', '_', '3', '_', '1', 0,
    'O', 'p', 'e', 'n', 'G', 'L', '_', 'V', 'e', 'r', 's', 'i', 'o', 'n', '_', '3', '_', '0', 0,
    'O', 'p', 'e', 'n', 'G', 'L', '_', 'V', 'e', 'r', 's', 'i', 'o', 'n', '_', '2', '_', '1', 0,
    'O', 'p', 'e', 'n', 'G', 'L', '_', 'V', 'e', 'r', 's', 'i', 'o', 'n', '_', '2', '_', '0', 0,
    'O', 'p', 'e', 'n', 'G', 'L', '_', 'V', 'e', 'r', 's', 'i', 'o', 'n', '_', '1', '_', '5', 0,
    'O', 'p', 'e', 'n', 'G', 'L', '_', 'V', 'e', 'r', 's', 'i', 'o', 'n', '_', '1', '_', '4', 0,
    'O', 'p', 'e', 'n', 'G', 'L', '_', 'V', 'e', 'r', 's', 'i', 'o', 'n', '_', '1', '_', '3', 0,
    'O', 'p', 'e', 'n', 'G', 'L', '_', 'V', 'e', 'r', 's', 'i', 'o', 'n', '_', '1', '_', '2', 0,
    'O', 'p', 'e', 'n', 'G', 'L', '_', 'V', 'e', 'r', 's', 'i', 'o', 'n', '_', '1', '_', '1', 0,
    'Q', 'G', 'L', ':', ':', 'F', 'o', 'r', 'm', 'a', 't', 'O', 'p', 't', 'i', 'o', 'n', 's', 0,
    'f', 'o', 'c', 'u', 's', 'P', 'r', 'e', 'v', 'i', 'o', 'u', 's', 'C', 'h', 'i', 'l', 'd', 0,
    'e', 's', 'c', 'a', 'p', 'e', 'B', 'u', 't', 't', 'o', 'n', 'N', 'u', 'm', 'b', 'e', 'r', 0,
    'f', 'o', 'c', 'u', 's', 'N', 'e', 'x', 't', 'P', 'r', 'e', 'v', 'C', 'h', 'i', 'l', 'd', 0,
    'Q', 'L', 'i', 's', 't', '<', 'Q', 'G', 'L', 'S', 'h', 'a', 'd', 'e', 'r', '*', '>', 0,
    'g', 'e', 'o', 'm', 'e', 't', 'r', 'y', 'I', 'n', 'p', 'u', 't', 'T', 'y', 'p', 'e', 0,
    's', 'e', 't', 'A', 't', 't', 'r', 'i', 'b', 'u', 't', 'e', 'V', 'a', 'l', 'u', 'e', 0,
    's', 'e', 't', 'A', 't', 't', 'r', 'i', 'b', 'u', 't', 'e', 'A', 'r', 'r', 'a', 'y', 0,
    'a', 't', 't', 'r', 'i', 'b', 'u', 't', 'e', 'L', 'o', 'c', 'a', 't', 'i', 'o', 'n', 0,
    'c', 'o', 'm', 'p', 'i', 'l', 'e', 'S', 'o', 'u', 'r', 'c', 'e', 'F', 'i', 'l', 'e', 0,
    'c', 'o', 'm', 'p', 'i', 'l', 'e', 'S', 'o', 'u', 'r', 'c', 'e', 'C', 'o', 'd', 'e', 0,
    'h', 'a', 's', 'O', 'p', 'e', 'n', 'G', 'L', 'P', 'b', 'u', 'f', 'f', 'e', 'r', 's', 0,
    'P', 'i', 'x', 'e', 'l', 'U', 'n', 'p', 'a', 'c', 'k', 'B', 'u', 'f', 'f', 'e', 'r', 0,
    'Q', 'G', 'L', 'B', 'u', 'f', 'f', 'e', 'r', ':', ':', 'A', 'c', 'c', 'e', 's', 's', 0,
    's', 'e', 't', 'A', 'u', 't', 'o', 'B', 'u', 'f', 'f', 'e', 'r', 'S', 'w', 'a', 'p', 0,
    'c', 'o', 'n', 'v', 'e', 'r', 't', 'T', 'o', 'G', 'L', 'F', 'o', 'r', 'm', 'a', 't', 0,
    'D', 'e', 'f', 'a', 'u', 'l', 't', 'B', 'i', 'n', 'd', 'O', 'p', 't', 'i', 'o', 'n', 0,
    't', 'e', 'x', 't', 'u', 'r', 'e', 'C', 'a', 'c', 'h', 'e', 'L', 'i', 'm', 'i', 't', 0,
    's', 'e', 't', 'B', 'l', 'u', 'e', 'B', 'u', 'f', 'f', 'e', 'r', 'S', 'i', 'z', 'e', 0,
    'h', 'a', 's', 'O', 'p', 'e', 'n', 'G', 'L', 'O', 'v', 'e', 'r', 'l', 'a', 'y', 's', 0,
    's', 't', 'e', 'n', 'c', 'i', 'l', 'B', 'u', 'f', 'f', 'e', 'r', 'S', 'i', 'z', 'e', 0,
    'I', 'n', 'd', 'i', 'r', 'e', 'c', 't', 'R', 'e', 'n', 'd', 'e', 'r', 'i', 'n', 'g', 0,
    'Q', 'G', 'L', ':', ':', 'F', 'o', 'r', 'm', 'a', 't', 'O', 'p', 't', 'i', 'o', 'n', 0,
    'd', 'e', 's', 't', 'r', 'o', 'y', 'S', 'u', 'b', 'W', 'i', 'n', 'd', 'o', 'w', 's', 0,
    'r', 'e', 's', 'e', 't', 'I', 'n', 'p', 'u', 't', 'C', 'o', 'n', 't', 'e', 'x', 't', 0,
    'm', 'o', 'u', 's', 'e', 'R', 'e', 'l', 'e', 'a', 's', 'e', 'E', 'v', 'e', 'n', 't', 0,
    's', 'e', 'n', 'd', 'e', 'r', 'S', 'i', 'g', 'n', 'a', 'l', 'I', 'n', 'd', 'e', 'x', 0,
    's', 'i', 'p', '.', 's', 'i', 'm', 'p', 'l', 'e', 'w', 'r', 'a', 'p', 'p', 'e', 'r', 0,
    'r', 'e', 'm', 'o', 'v', 'e', 'A', 'l', 'l', 'S', 'h', 'a', 'd', 'e', 'r', 's', 0,
    'Q', 'G', 'L', 'S', 'h', 'a', 'd', 'e', 'r', 'P', 'r', 'o', 'g', 'r', 'a', 'm', 0,
    'h', 'a', 's', 'O', 'p', 'e', 'n', 'G', 'L', 'S', 'h', 'a', 'd', 'e', 'r', 's', 0,
    's', 'e', 't', 'T', 'e', 'x', 't', 'u', 'r', 'e', 'T', 'a', 'r', 'g', 'e', 't', 0,
    'd', 'e', 'l', 'e', 't', 'e', 'O', 'l', 'd', 'C', 'o', 'n', 't', 'e', 'x', 't', 0,
    'M', 'i', 'p', 'm', 'a', 'p', 'B', 'i', 'n', 'd', 'O', 'p', 't', 'i', 'o', 'n', 0,
    's', 'e', 't', 'W', 'i', 'n', 'd', 'o', 'w', 'C', 'r', 'e', 'a', 't', 'e', 'd', 0,
    's', 'e', 't', 'R', 'e', 'd', 'B', 'u', 'f', 'f', 'e', 'r', 'S', 'i', 'z', 'e', 0,
    's', 'e', 't', 'S', 'a', 'm', 'p', 'l', 'e', 'B', 'u', 'f', 'f', 'e', 'r', 's', 0,
    's', 'e', 't', 'M', 'o', 'u', 's', 'e', 'T', 'r', 'a', 'c', 'k', 'i', 'n', 'g', 0,
    'd', 'e', 's', 't', 'r', 'o', 'y', 'O', 'l', 'd', 'W', 'i', 'n', 'd', 'o', 'w', 0,
    'i', 'n', 'i', 't', 'i', 'a', 'l', 'i', 'z', 'e', 'W', 'i', 'n', 'd', 'o', 'w', 0,
    'u', 'p', 'd', 'a', 't', 'e', 'M', 'i', 'c', 'r', 'o', 'F', 'o', 'c', 'u', 's', 0,
    'c', 'o', 'n', 't', 'e', 'x', 't', 'M', 'e', 'n', 'u', 'E', 'v', 'e', 'n', 't', 0,
    'i', 'n', 'p', 'u', 't', 'M', 'e', 't', 'h', 'o', 'd', 'E', 'v', 'e', 'n', 't', 0,
    'i', 'n', 'p', 'u', 't', 'M', 'e', 't', 'h', 'o', 'd', 'Q', 'u', 'e', 'r', 'y', 0,
    's', 'e', 't', 'D', 'e', 'f', 'a', 'u', 'l', 't', 'F', 'o', 'r', 'm', 'a', 't', 0,
    'd', 'i', 's', 'c', 'o', 'n', 'n', 'e', 'c', 't', 'N', 'o', 't', 'i', 'f', 'y', 0,
    's', 'e', 't', 'U', 'n', 'i', 'f', 'o', 'r', 'm', 'V', 'a', 'l', 'u', 'e', 0,
    'u', 'n', 'i', 'f', 'o', 'r', 'm', 'L', 'o', 'c', 'a', 't', 'i', 'o', 'n', 0,
    'b', 'l', 'i', 't', 'F', 'r', 'a', 'm', 'e', 'b', 'u', 'f', 'f', 'e', 'r', 0,
    's', 'e', 't', 'U', 's', 'a', 'g', 'e', 'P', 'a', 't', 't', 'e', 'r', 'n', 0,
    'P', 'i', 'x', 'e', 'l', 'P', 'a', 'c', 'k', 'B', 'u', 'f', 'f', 'e', 'r', 0,
    'Q', 'G', 'L', 'B', 'u', 'f', 'f', 'e', 'r', ':', ':', 'T', 'y', 'p', 'e', 0,
    'r', 'e', 's', 'i', 'z', 'e', 'O', 'v', 'e', 'r', 'l', 'a', 'y', 'G', 'L', 0,
    'u', 'p', 'd', 'a', 't', 'e', 'O', 'v', 'e', 'r', 'l', 'a', 'y', 'G', 'L', 0,
    'g', 'r', 'a', 'b', 'F', 'r', 'a', 'm', 'e', 'B', 'u', 'f', 'f', 'e', 'r', 0,
    'r', 'e', 'q', 'u', 'e', 's', 't', 'e', 'd', 'F', 'o', 'r', 'm', 'a', 't', 0,
    's', 'e', 't', 'S', 'w', 'a', 'p', 'I', 'n', 't', 'e', 'r', 'v', 'a', 'l', 0,
    'g', 'r', 'e', 'e', 'n', 'B', 'u', 'f', 'f', 'e', 'r', 'S', 'i', 'z', 'e', 0,
    's', 'e', 't', 'D', 'o', 'u', 'b', 'l', 'e', 'B', 'u', 'f', 'f', 'e', 'r', 0,
    'a', 'l', 'p', 'h', 'a', 'B', 'u', 'f', 'f', 'e', 'r', 'S', 'i', 'z', 'e', 0,
    'a', 'c', 'c', 'u', 'm', 'B', 'u', 'f', 'f', 'e', 'r', 'S', 'i', 'z', 'e', 0,
    'd', 'e', 'p', 't', 'h', 'B', 'u', 'f', 'f', 'e', 'r', 'S', 'i', 'z', 'e', 0,
    'N', 'o', 'S', 'a', 'm', 'p', 'l', 'e', 'B', 'u', 'f', 'f', 'e', 'r', 's', 0,
    'N', 'o', 'S', 't', 'e', 'r', 'e', 'o', 'B', 'u', 'f', 'f', 'e', 'r', 's', 0,
    'N', 'o', 'S', 't', 'e', 'n', 'c', 'i', 'l', 'B', 'u', 'f', 'f', 'e', 'r', 0,
    'a', 's', 'p', 'e', 'c', 't', 'R', 'a', 't', 'i', 'o', 'M', 'o', 'd', 'e', 0,
    'd', 'e', 'v', 'i', 'c', 'e', 'T', 'r', 'a', 'n', 's', 'f', 'o', 'r', 'm', 0,
    'm', 'i', 'n', 'i', 'm', 'u', 'm', 'S', 'i', 'z', 'e', 'H', 'i', 'n', 't', 0,
    'm', 'o', 'u', 's', 'e', 'P', 'r', 'e', 's', 's', 'E', 'v', 'e', 'n', 't', 0,
    'k', 'e', 'y', 'R', 'e', 'l', 'e', 'a', 's', 'e', 'E', 'v', 'e', 'n', 't', 0,
    'Q', 'G', 'L', 'P', 'i', 'x', 'e', 'l', 'B', 'u', 'f', 'f', 'e', 'r', 0,
    'i', 'n', 't', 'e', 'r', 'n', 'a', 'l', 'F', 'o', 'r', 'm', 'a', 't', 0,
    'a', 'u', 't', 'o', 'B', 'u', 'f', 'f', 'e', 'r', 'S', 'w', 'a', 'p', 0,
    'p', 'a', 'i', 'n', 't', 'O', 'v', 'e', 'r', 'l', 'a', 'y', 'G', 'L', 0,
    'o', 'v', 'e', 'r', 'l', 'a', 'y', 'C', 'o', 'n', 't', 'e', 'x', 't', 0,
    's', 'e', 't', 'I', 'n', 'i', 't', 'i', 'a', 'l', 'i', 'z', 'e', 'd', 0,
    'd', 'e', 'v', 'i', 'c', 'e', 'I', 's', 'P', 'i', 'x', 'm', 'a', 'p', 0,
    'c', 'u', 'r', 'r', 'e', 'n', 't', 'C', 'o', 'n', 't', 'e', 'x', 't', 0,
    'g', 'e', 't', 'P', 'r', 'o', 'c', 'A', 'd', 'd', 'r', 'e', 's', 's', 0,
    'b', 'l', 'u', 'e', 'B', 'u', 'f', 'f', 'e', 'r', 'S', 'i', 'z', 'e', 0,
    'N', 'o', 'A', 'l', 'p', 'h', 'a', 'C', 'h', 'a', 'n', 'n', 'e', 'l', 0,
    'l', 'a', 'n', 'g', 'u', 'a', 'g', 'e', 'C', 'h', 'a', 'n', 'g', 'e', 0,
    'f', 'o', 'c', 'u', 's', 'N', 'e', 'x', 't', 'C', 'h', 'i', 'l', 'd', 0,
    's', 'e', 'l', 'e', 'c', 't', 'e', 'd', 'F', 'i', 'l', 't', 'e', 'r', 0,
    'h', 'e', 'i', 'g', 'h', 't', 'F', 'o', 'r', 'W', 'i', 'd', 't', 'h', 0,
    'd', 'r', 'a', 'g', 'L', 'e', 'a', 'v', 'e', 'E', 'v', 'e', 'n', 't', 0,
    'd', 'r', 'a', 'g', 'E', 'n', 't', 'e', 'r', 'E', 'v', 'e', 'n', 't', 0,
    'm', 'o', 'u', 's', 'e', 'M', 'o', 'v', 'e', 'E', 'v', 'e', 'n', 't', 0,
    'P', 'y', 'Q', 't', '4', '.', 'Q', 't', 'O', 'p', 'e', 'n', 'G', 'L', 0,
    's', 'e', 't', 'A', 't', 't', 'a', 'c', 'h', 'm', 'e', 'n', 't', 0,
    'q', 'g', 'l', 'C', 'l', 'e', 'a', 'r', 'C', 'o', 'l', 'o', 'r', 0,
    'w', 'i', 'n', 'd', 'o', 'w', 'C', 'r', 'e', 'a', 't', 'e', 'd', 0,
    'c', 'h', 'o', 'o', 's', 'e', 'C', 'o', 'n', 't', 'e', 'x', 't', 0,
    'd', 'e', 'l', 'e', 't', 'e', 'T', 'e', 'x', 't', 'u', 'r', 'e', 0,
    't', 'e', 'x', 't', 'u', 'r', 'e', 'T', 'a', 'r', 'g', 'e', 't', 0,
    'r', 'e', 'd', 'B', 'u', 'f', 'f', 'e', 'r', 'S', 'i', 'z', 'e', 0,
    's', 'a', 'm', 'p', 'l', 'e', 'B', 'u', 'f', 'f', 'e', 'r', 's', 0,
    'N', 'o', 'A', 'c', 'c', 'u', 'm', 'B', 'u', 'f', 'f', 'e', 'r', 0,
    'N', 'o', 'D', 'e', 'p', 't', 'h', 'B', 'u', 'f', 'f', 'e', 'r', 0,
    'c', 'h', 'a', 'n', 'g', 'e', 'd', 'S', 'i', 'g', 'n', 'a', 'l', 0,
    'p', 'a', 'l', 'e', 't', 't', 'e', 'C', 'h', 'a', 'n', 'g', 'e', 0,
    'e', 'n', 'a', 'b', 'l', 'e', 'd', 'C', 'h', 'a', 'n', 'g', 'e', 0,
    'd', 'e', 's', 't', 'r', 'o', 'y', 'W', 'i', 'n', 'd', 'o', 'w', 0,
    't', 'r', 'a', 'n', 's', 'f', 'o', 'r', 'm', 'M', 'o', 'd', 'e', 0,
    't', 'h', 'r', 'e', 's', 'h', 'o', 'l', 'd', 'T', 'i', 'm', 'e', 0,
    'd', 'r', 'a', 'g', 'M', 'o', 'v', 'e', 'E', 'v', 'e', 'n', 't', 0,
    'f', 'o', 'c', 'u', 's', 'O', 'u', 't', 'E', 'v', 'e', 'n', 't', 0,
    'k', 'e', 'y', 'P', 'r', 'e', 's', 's', 'E', 'v', 'e', 'n', 't', 0,
    'd', 'e', 'f', 'a', 'u', 'l', 't', 'F', 'o', 'r', 'm', 'a', 't', 0,
    'r', 'e', 'm', 'o', 'v', 'e', 'S', 'h', 'a', 'd', 'e', 'r', 0,
    'N', 'o', 'A', 't', 't', 'a', 'c', 'h', 'm', 'e', 'n', 't', 0,
    'u', 's', 'a', 'g', 'e', 'P', 'a', 't', 't', 'e', 'r', 'n', 0,
    'V', 'e', 'r', 't', 'e', 'x', 'B', 'u', 'f', 'f', 'e', 'r', 0,
    'i', 'n', 'i', 't', 'i', 'a', 'l', 'i', 'z', 'e', 'G', 'L', 0,
    'r', 'e', 'n', 'd', 'e', 'r', 'P', 'i', 'x', 'm', 'a', 'p', 0,
    'N', 'o', 'B', 'i', 'n', 'd', 'O', 'p', 't', 'i', 'o', 'n', 0,
    'c', 'h', 'o', 'o', 's', 'e', 'V', 'i', 's', 'u', 'a', 'l', 0,
    's', 'h', 'a', 'r', 'e', 'C', 'o', 'n', 't', 'e', 'x', 't', 0,
    'm', 'i', 'n', 'o', 'r', 'V', 'e', 'r', 's', 'i', 'o', 'n', 0,
    'm', 'a', 'j', 'o', 'r', 'V', 'e', 'r', 's', 'i', 'o', 'n', 0,
    's', 'w', 'a', 'p', 'I', 'n', 't', 'e', 'r', 'v', 'a', 'l', 0,
    'd', 'o', 'u', 'b', 'l', 'e', 'B', 'u', 'f', 'f', 'e', 'r', 0,
    'S', 'i', 'n', 'g', 'l', 'e', 'B', 'u', 'f', 'f', 'e', 'r', 0,
    's', 'o', 'u', 'r', 'c', 'e', 'R', 'e', 'g', 'i', 'o', 'n', 0,
    't', 'a', 'r', 'g', 'e', 't', 'O', 'f', 'f', 's', 'e', 't', 0,
    'b', 'o', 'u', 'n', 'd', 'i', 'n', 'g', 'R', 'e', 'c', 't', 0,
    'm', 'i', 'd', 'L', 'i', 'n', 'e', 'W', 'i', 'd', 't', 'h', 0,
    'f', 'o', 'c', 'u', 's', 'I', 'n', 'E', 'v', 'e', 'n', 't', 0,
    'f', 'i', 'n', 'd', 'N', 'e', 'a', 'r', 'e', 's', 't', 0,
    'Q', 'G', 'L', 'C', 'o', 'l', 'o', 'r', 'm', 'a', 'p', 0,
    'D', 'y', 'n', 'a', 'm', 'i', 'c', 'C', 'o', 'p', 'y', 0,
    'D', 'y', 'n', 'a', 'm', 'i', 'c', 'R', 'e', 'a', 'd', 0,
    'D', 'y', 'n', 'a', 'm', 'i', 'c', 'D', 'r', 'a', 'w', 0,
    'I', 'n', 'd', 'e', 'x', 'B', 'u', 'f', 'f', 'e', 'r', 0,
    's', 'e', 't', 'C', 'o', 'l', 'o', 'r', 'm', 'a', 'p', 0,
    's', 'h', 'a', 'r', 'e', 'W', 'i', 'd', 'g', 'e', 't', 0,
    'i', 'n', 'i', 't', 'i', 'a', 'l', 'i', 'z', 'e', 'd', 0,
    'd', 'r', 'a', 'w', 'T', 'e', 'x', 't', 'u', 'r', 'e', 0,
    'b', 'i', 'n', 'd', 'T', 'e', 'x', 't', 'u', 'r', 'e', 0,
    's', 'w', 'a', 'p', 'B', 'u', 'f', 'f', 'e', 'r', 's', 0,
    'd', 'o', 'n', 'e', 'C', 'u', 'r', 'r', 'e', 'n', 't', 0,
    'm', 'a', 'k', 'e', 'C', 'u', 'r', 'r', 'e', 'n', 't', 0,
    'C', 'o', 'r', 'e', 'P', 'r', 'o', 'f', 'i', 'l', 'e', 0,
    't', 'a', 'b', 'l', 'e', 't', 'E', 'v', 'e', 'n', 't', 0,
    'b', 'u', 't', 't', 'o', 'n', '2', 'T', 'e', 'x', 't', 0,
    'b', 'u', 't', 't', 'o', 'n', '1', 'T', 'e', 'x', 't', 0,
    'a', 'c', 't', 'i', 'o', 'n', 'E', 'v', 'e', 'n', 't', 0,
    'p', 'a', 'i', 'n', 't', 'E', 'n', 'g', 'i', 'n', 'e', 0,
    'r', 'e', 's', 'i', 'z', 'e', 'E', 'v', 'e', 'n', 't', 0,
    'c', 'h', 'a', 'n', 'g', 'e', 'E', 'v', 'e', 'n', 't', 0,
    'c', 'u', 's', 't', 'o', 'm', 'E', 'v', 'e', 'n', 't', 0,
    'e', 'v', 'e', 'n', 't', 'F', 'i', 'l', 't', 'e', 'r', 0,
    'i', 's', 'C', 'o', 'm', 'p', 'i', 'l', 'e', 'd', 0,
    's', 'o', 'u', 'r', 'c', 'e', 'C', 'o', 'd', 'e', 0,
    's', 'h', 'a', 'd', 'e', 'r', 'T', 'y', 'p', 'e', 0,
    'a', 't', 't', 'a', 'c', 'h', 'm', 'e', 'n', 't', 0,
    'e', 'n', 't', 'r', 'y', 'C', 'o', 'l', 'o', 'r', 0,
    's', 'e', 't', 'E', 'n', 't', 'r', 'i', 'e', 's', 0,
    'S', 't', 'a', 't', 'i', 'c', 'C', 'o', 'p', 'y', 0,
    'S', 't', 'a', 't', 'i', 'c', 'R', 'e', 'a', 'd', 0,
    'S', 't', 'a', 't', 'i', 'c', 'D', 'r', 'a', 'w', 0,
    'S', 't', 'r', 'e', 'a', 'm', 'C', 'o', 'p', 'y', 0,
    'S', 't', 'r', 'e', 'a', 'm', 'R', 'e', 'a', 'd', 0,
    'S', 't', 'r', 'e', 'a', 'm', 'D', 'r', 'a', 'w', 0,
    'r', 'e', 'n', 'd', 'e', 'r', 'T', 'e', 'x', 't', 0,
    'u', 's', 'e', 'C', 'o', 'n', 't', 'e', 'x', 't', 0,
    'a', 'r', 'e', 'S', 'h', 'a', 'r', 'i', 'n', 'g', 0,
    'Q', 'G', 'L', 'C', 'o', 'n', 't', 'e', 'x', 't', 0,
    's', 'e', 't', 'P', 'r', 'o', 'f', 'i', 'l', 'e', 0,
    'h', 'a', 's', 'O', 'v', 'e', 'r', 'l', 'a', 'y', 0,
    's', 'e', 't', 'O', 'v', 'e', 'r', 'l', 'a', 'y', 0,
    's', 'e', 't', 'S', 't', 'e', 'n', 'c', 'i', 'l', 0,
    's', 'e', 't', 'S', 'a', 'm', 'p', 'l', 'e', 's', 0,
    'C', 'o', 'l', 'o', 'r', 'I', 'n', 'd', 'e', 'x', 0,
    'H', 'a', 's', 'O', 'v', 'e', 'r', 'l', 'a', 'y', 0,
    'f', 'o', 'n', 't', 'C', 'h', 'a', 'n', 'g', 'e', 0,
    's', 'e', 't', 'C', 'o', 'n', 't', 'e', 'x', 't', 0,
    'e', 'n', 't', 'e', 'r', 'E', 'v', 'e', 'n', 't', 0,
    'l', 'e', 'a', 'v', 'e', 'E', 'v', 'e', 'n', 't', 0,
    'c', 'o', 'l', 'u', 'm', 'n', 'S', 'p', 'a', 'n', 0,
    'c', 'o', 'n', 's', 't', 'r', 'a', 'i', 'n', 't', 0,
    't', 'e', 's', 't', 'O', 'p', 't', 'i', 'o', 'n', 0,
    's', 'e', 't', 'V', 'i', 's', 'i', 'b', 'l', 'e', 0,
    'c', 'l', 'o', 's', 'e', 'E', 'v', 'e', 'n', 't', 0,
    'r', 'e', 'p', 'e', 'a', 't', 'T', 'i', 'm', 'e', 0,
    'w', 'h', 'e', 'e', 'l', 'E', 'v', 'e', 'n', 't', 0,
    'p', 'a', 'i', 'n', 't', 'E', 'v', 'e', 'n', 't', 0,
    'f', 'i', 'e', 'l', 'd', 'W', 'i', 'd', 't', 'h', 0,
    'c', 'h', 'i', 'l', 'd', 'E', 'v', 'e', 'n', 't', 0,
    't', 'i', 'm', 'e', 'r', 'E', 'v', 'e', 'n', 't', 0,
    's', 'e', 't', 'V', 'e', 'r', 's', 'i', 'o', 'n', 0,
    '_', '_', 'i', 'n', 'v', 'e', 'r', 't', '_', '_', 0,
    'p', 'r', 'o', 'g', 'r', 'a', 'm', 'I', 'd', 0,
    'a', 'd', 'd', 'S', 'h', 'a', 'd', 'e', 'r', 0,
    'Q', 'G', 'L', 'S', 'h', 'a', 'd', 'e', 'r', 0,
    's', 'e', 't', 'M', 'i', 'p', 'm', 'a', 'p', 0,
    's', 'e', 't', 'H', 'a', 'n', 'd', 'l', 'e', 0,
    'i', 's', 'C', 'r', 'e', 'a', 't', 'e', 'd', 0,
    'Q', 'G', 'L', 'B', 'u', 'f', 'f', 'e', 'r', 0,
    'w', 'i', 't', 'h', 'A', 'l', 'p', 'h', 'a', 0,
    'Q', 'G', 'L', 'W', 'i', 'd', 'g', 'e', 't', 0,
    'i', 's', 'S', 'h', 'a', 'r', 'i', 'n', 'g', 0,
    'N', 'o', 'P', 'r', 'o', 'f', 'i', 'l', 'e', 0,
    'h', 'a', 's', 'O', 'p', 'e', 'n', 'G', 'L', 0,
    's', 'e', 't', 'S', 't', 'e', 'r', 'e', 'o', 0,
    'Q', 'G', 'L', 'F', 'o', 'r', 'm', 'a', 't', 0,
    'N', 'o', 'O', 'v', 'e', 'r', 'l', 'a', 'y', 0,
    'o', 'p', 'e', 'r', 'a', 't', 'i', 'o', 'n', 0,
    's', 'e', 't', 'F', 'o', 'r', 'm', 'a', 't', 0,
    'm', 'o', 'v', 'e', 'E', 'v', 'e', 'n', 't', 0,
    'l', 'i', 'n', 'e', 'W', 'i', 'd', 't', 'h', 0,
    's', 'e', 't', 'O', 'p', 't', 'i', 'o', 'n', 0,
    's', 'h', 'o', 'w', 'E', 'v', 'e', 'n', 't', 0,
    'h', 'i', 'd', 'e', 'E', 'v', 'e', 'n', 't', 0,
    'd', 'r', 'o', 'p', 'E', 'v', 'e', 'n', 't', 0,
    'd', 'i', 'r', 'e', 'c', 't', 'o', 'r', 'y', 0,
    'a', 'l', 'i', 'g', 'n', 'm', 'e', 'n', 't', 0,
    'r', 'e', 'c', 'e', 'i', 'v', 'e', 'r', 's', 0,
    'R', 'e', 'a', 'd', 'W', 'r', 'i', 't', 'e', 0,
    'W', 'r', 'i', 't', 'e', 'O', 'n', 'l', 'y', 0,
    'p', 'r', 'e', 'c', 'i', 's', 'i', 'o', 'n', 0,
    'i', 's', 'L', 'i', 'n', 'k', 'e', 'd', 0,
    's', 'h', 'a', 'd', 'e', 'r', 'I', 'd', 0,
    'G', 'e', 'o', 'm', 'e', 't', 'r', 'y', 0,
    'F', 'r', 'a', 'g', 'm', 'e', 'n', 't', 0,
    'e', 'n', 't', 'r', 'y', 'R', 'g', 'b', 0,
    's', 'e', 't', 'E', 'n', 't', 'r', 'y', 0,
    'a', 'l', 'l', 'o', 'c', 'a', 't', 'e', 0,
    'b', 'u', 'f', 'f', 'e', 'r', 'I', 'd', 0,
    'r', 'e', 's', 'i', 'z', 'e', 'G', 'L', 0,
    'u', 'p', 'd', 'a', 't', 'e', 'G', 'L', 0,
    'q', 'g', 'l', 'C', 'o', 'l', 'o', 'r', 0,
    'l', 'i', 's', 't', 'B', 'a', 's', 'e', 0,
    's', 'e', 't', 'P', 'l', 'a', 'n', 'e', 0,
    's', 'e', 't', 'A', 'c', 'c', 'u', 'm', 0,
    's', 'e', 't', 'D', 'e', 'p', 't', 'h', 0,
    'f', 'i', 'l', 'l', 'R', 'u', 'l', 'e', 0,
    't', 'a', 'b', 'A', 'r', 'r', 'a', 'y', 0,
    't', 'a', 'b', 'S', 't', 'o', 'p', 's', 0,
    'u', 's', 'e', 'r', 'D', 'a', 't', 'a', 0,
    's', 'e', 't', 'A', 'l', 'p', 'h', 'a', 0,
    'c', 'o', 'l', 'o', 'r', 'm', 'a', 'p', 0,
    's', 'i', 'z', 'e', 'H', 'i', 'n', 't', 0,
    's', 'h', 'o', 'r', 't', 'c', 'u', 't', 0,
    'b', 'e', 'h', 'a', 'v', 'i', 'o', 'r', 0,
    'p', 'o', 's', 'i', 't', 'i', 'o', 'n', 0,
    'f', 'i', 'l', 'l', 'C', 'h', 'a', 'r', 0,
    'p', 'r', 'o', 'p', 'e', 'r', 't', 'y', 0,
    'R', 'e', 'a', 'd', 'O', 'n', 'l', 'y', 0,
    '_', '_', 'b', 'o', 'o', 'l', '_', '_', 0,
    '_', '_', 'i', 'x', 'o', 'r', '_', '_', 0,
    '_', '_', 'i', 'a', 'n', 'd', '_', '_', 0,
    's', 'h', 'a', 'd', 'e', 'r', 's', 0,
    'i', 's', 'B', 'o', 'u', 'n', 'd', 0,
    'p', 'a', 'i', 'n', 't', 'G', 'L', 0,
    'p', 'r', 'o', 'f', 'i', 'l', 'e', 0,
    's', 't', 'e', 'n', 'c', 'i', 'l', 0,
    's', 'a', 'm', 'p', 'l', 'e', 's', 0,
    'd', 'e', 's', 't', 'r', 'o', 'y', 0,
    'e', 'x', 'p', 'o', 's', 'e', 'd', 0,
    't', 'o', 'I', 'm', 'a', 'g', 'e', 0,
    'b', 'u', 't', 't', 'o', 'n', '2', 0,
    'b', 'u', 't', 't', 'o', 'n', '1', 0,
    'q', 'u', 'a', 'l', 'i', 't', 'y', 0,
    'd', 'e', 'v', 'T', 'y', 'p', 'e', 0,
    'y', 'M', 'a', 'r', 'g', 'i', 'n', 0,
    'x', 'M', 'a', 'r', 'g', 'i', 'n', 0,
    'r', 'o', 'w', 'S', 'p', 'a', 'n', 0,
    'c', 'a', 'p', 't', 'i', 'o', 'n', 0,
    't', 'e', 'x', 't', 'u', 'r', 'e', 0,
    's', 'e', 't', 'R', 'g', 'b', 'a', 0,
    'r', 'e', 'l', 'e', 'a', 's', 'e', 0,
    'o', 'p', 't', 'i', 'o', 'n', 's', 0,
    'e', 'n', 'a', 'b', 'l', 'e', 'd', 0,
    'c', 'o', 'n', 't', 'e', 'x', 't', 0,
    'i', 's', 'E', 'm', 'p', 't', 'y', 0,
    'i', 's', 'V', 'a', 'l', 'i', 'd', 0,
    'f', 'i', 'l', 't', 'e', 'r', 's', 0,
    '_', '_', 'x', 'o', 'r', '_', '_', 0,
    '_', '_', 'i', 'o', 'r', '_', '_', 0,
    '_', '_', 'a', 'n', 'd', '_', '_', 0,
    '_', '_', 'i', 'n', 't', '_', '_', 0,
    's', 't', 'r', 'i', 'd', 'e', 0,
    'V', 'e', 'r', 't', 'e', 'x', 0,
    'm', 'i', 'p', 'm', 'a', 'p', 0,
    'g', 'l', 'D', 'r', 'a', 'w', 0,
    'g', 'l', 'I', 'n', 'i', 't', 0,
    's', 't', 'e', 'r', 'e', 'o', 0,
    'y', 'R', 'o', 'u', 'n', 'd', 0,
    'x', 'R', 'o', 'u', 'n', 'd', 0,
    'm', 'e', 't', 'r', 'i', 'c', 0,
    'l', 'a', 'y', 'e', 'r', 's', 0,
    'w', 'i', 'n', 'd', 'o', 'w', 0,
    's', 'u', 'n', 'k', 'e', 'n', 0,
    'o', 'p', 't', 'i', 'o', 'n', 0,
    'w', 'i', 'd', 'g', 'e', 't', 0,
    'h', 'e', 'i', 'g', 'h', 't', 0,
    'p', 'r', 'o', 'p', 'e', 'r', 0,
    's', 'e', 'n', 'd', 'e', 'r', 0,
    'v', 'a', 'l', 'u', 'e', '9', 0,
    'v', 'a', 'l', 'u', 'e', '8', 0,
    'v', 'a', 'l', 'u', 'e', '7', 0,
    'v', 'a', 'l', 'u', 'e', '6', 0,
    'v', 'a', 'l', 'u', 'e', '5', 0,
    'v', 'a', 'l', 'u', 'e', '4', 0,
    'v', 'a', 'l', 'u', 'e', '3', 0,
    'v', 'a', 'l', 'u', 'e', '2', 0,
    'v', 'a', 'l', 'u', 'e', '1', 0,
    'v', 'a', 'l', 'u', 'e', '0', 0,
    's', 'y', 's', 't', 'e', 'm', 0,
    's', 'y', 'm', 'b', 'o', 'l', 0,
    's', 'u', 'f', 'f', 'i', 'x', 0,
    'p', 'r', 'e', 'f', 'i', 'x', 0,
    'd', 'e', 'v', 'i', 'c', 'e', 0,
    'f', 'o', 'r', 'm', 'a', 't', 0,
    'd', 'e', 't', 'a', 'c', 'h', 0,
    't', 'a', 'r', 'g', 'e', 't', 0,
    'a', 'c', 't', 'i', 'o', 'n', 0,
    'c', 'o', 'l', 'u', 'm', 'n', 0,
    'o', 'f', 'f', 's', 'e', 't', 0,
    'c', 'r', 'e', 'a', 't', 'e', 0,
    'h', 'a', 'n', 'd', 'l', 'e', 0,
    'f', 'i', 'l', 't', 'e', 'r', 0,
    'o', 'b', 'j', 'e', 'c', 't', 0,
    'p', 'a', 'r', 'e', 'n', 't', 0,
    '_', '_', 'n', 'e', '_', '_', 0,
    '_', '_', 'e', 'q', '_', '_', 0,
    '_', '_', 'o', 'r', '_', '_', 0,
    'a', 'c', 'c', 'u', 'm', 0,
    'p', 'l', 'a', 'n', 'e', 0,
    'd', 'e', 'p', 't', 'h', 0,
    'b', 'r', 'u', 's', 'h', 0,
    'a', 'l', 'p', 'h', 'a', 0,
    'h', 'i', 'n', 't', 's', 0,
    'w', 'i', 'd', 't', 'h', 0,
    'r', 'e', 's', 'e', 't', 0,
    'u', 'n', 'm', 'a', 'p', 0,
    'w', 'r', 'i', 't', 'e', 0,
    'f', 'l', 'a', 'g', 's', 0,
    'e', 'v', 'e', 'n', 't', 0,
    'm', 's', 'e', 'c', 's', 0,
    's', 't', 'a', 't', 'e', 0,
    'b', 'i', 'n', 'd', 0,
    'f', 'i', 'n', 'd', 0,
    'r', 'g', 'b', 'a', 0,
    'f', 'o', 'n', 't', 0,
    'm', 'o', 'd', 'e', 0,
    'n', 'a', 'm', 'e', 0,
    'b', 'a', 's', 'e', 0,
    'f', 'i', 'l', 'l', 0,
    'f', 'r', 'o', 'm', 0,
    's', 'o', 'r', 't', 0,
    'r', 'e', 'a', 'd', 0,
    't', 'y', 'p', 'e', 0,
    'l', 'i', 'n', 'k', 0,
    's', 'i', 'z', 'e', 0,
    'l', 'o', 'g', 0,
    'Q', 'G', 'L', 0,
    'p', 'e', 'n', 0,
    'e', 'n', 'd', 0,
    'p', 'o', 's', 0,
    's', 'w', 0,
    's', 'y', 0,
    's', 'x', 0,
};

bool sipVH_QtOpenGL_38(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod)
{
    bool sipRes = 0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "");

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "b", &sipRes);

    return sipRes;
}

void sipVH_QtOpenGL_37(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, int a0,int a1)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "ii", a0, a1);
}

void sipVH_QtOpenGL_36(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const char*a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "S", a0);
}

void sipVH_QtOpenGL_35(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QChildEvent*a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "D", a0, sipType_QChildEvent, NULL);
}

void sipVH_QtOpenGL_34(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QTimerEvent*a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "D", a0, sipType_QTimerEvent, NULL);
}

bool sipVH_QtOpenGL_33(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QObject*a0, ::QEvent*a1)
{
    bool sipRes = 0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "DD", a0, sipType_QObject, NULL, a1, sipType_QEvent, NULL);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "b", &sipRes);

    return sipRes;
}

bool sipVH_QtOpenGL_32(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QEvent*a0)
{
    bool sipRes = 0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "D", a0, sipType_QEvent, NULL);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "b", &sipRes);

    return sipRes;
}

int sipVH_QtOpenGL_31(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QPaintDevice::PaintDeviceMetric a0)
{
    int sipRes = 0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "F", a0, sipType_QPaintDevice_PaintDeviceMetric);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "i", &sipRes);

    return sipRes;
}

 ::QPaintEngine* sipVH_QtOpenGL_30(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod)
{
     ::QPaintEngine* sipRes = 0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "");

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "H0", sipType_QPaintEngine, &sipRes);

    return sipRes;
}

int sipVH_QtOpenGL_29(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod)
{
    int sipRes = 0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "");

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "i", &sipRes);

    return sipRes;
}

 ::QSize sipVH_QtOpenGL_28(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod)
{
     ::QSize sipRes;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "");

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "H5", sipType_QSize, &sipRes);

    return sipRes;
}

int sipVH_QtOpenGL_27(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, int a0)
{
    int sipRes = 0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "i", a0);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "i", &sipRes);

    return sipRes;
}

void sipVH_QtOpenGL_26(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QMouseEvent*a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "D", a0, sipType_QMouseEvent, NULL);
}

void sipVH_QtOpenGL_25(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QWheelEvent*a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "D", a0, sipType_QWheelEvent, NULL);
}

void sipVH_QtOpenGL_24(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QKeyEvent*a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "D", a0, sipType_QKeyEvent, NULL);
}

void sipVH_QtOpenGL_23(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QFocusEvent*a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "D", a0, sipType_QFocusEvent, NULL);
}

void sipVH_QtOpenGL_22(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QPaintEvent*a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "D", a0, sipType_QPaintEvent, NULL);
}

void sipVH_QtOpenGL_21(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QMoveEvent*a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "D", a0, sipType_QMoveEvent, NULL);
}

void sipVH_QtOpenGL_20(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QResizeEvent*a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "D", a0, sipType_QResizeEvent, NULL);
}

void sipVH_QtOpenGL_19(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QCloseEvent*a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "D", a0, sipType_QCloseEvent, NULL);
}

void sipVH_QtOpenGL_18(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QContextMenuEvent*a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "D", a0, sipType_QContextMenuEvent, NULL);
}

void sipVH_QtOpenGL_17(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QTabletEvent*a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "D", a0, sipType_QTabletEvent, NULL);
}

void sipVH_QtOpenGL_16(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QActionEvent*a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "D", a0, sipType_QActionEvent, NULL);
}

void sipVH_QtOpenGL_15(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QDragEnterEvent*a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "D", a0, sipType_QDragEnterEvent, NULL);
}

void sipVH_QtOpenGL_14(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QDragMoveEvent*a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "D", a0, sipType_QDragMoveEvent, NULL);
}

void sipVH_QtOpenGL_13(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QDragLeaveEvent*a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "D", a0, sipType_QDragLeaveEvent, NULL);
}

void sipVH_QtOpenGL_12(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QDropEvent*a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "D", a0, sipType_QDropEvent, NULL);
}

void sipVH_QtOpenGL_11(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QShowEvent*a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "D", a0, sipType_QShowEvent, NULL);
}

void sipVH_QtOpenGL_10(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QHideEvent*a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "D", a0, sipType_QHideEvent, NULL);
}

void sipVH_QtOpenGL_9(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QEvent*a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "D", a0, sipType_QEvent, NULL);
}

void sipVH_QtOpenGL_8(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::QInputMethodEvent*a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "D", a0, sipType_QInputMethodEvent, NULL);
}

 ::QVariant sipVH_QtOpenGL_7(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod,  ::Qt::InputMethodQuery a0)
{
     ::QVariant sipRes;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "F", a0, sipType_Qt_InputMethodQuery);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "H5", sipType_QVariant, &sipRes);

    return sipRes;
}

bool sipVH_QtOpenGL_6(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, bool a0)
{
    bool sipRes = 0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "b", a0);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "b", &sipRes);

    return sipRes;
}

void sipVH_QtOpenGL_5(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const  ::QPalette& a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "N", new  ::QPalette(a0), sipType_QPalette, NULL);
}

void sipVH_QtOpenGL_4(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const  ::QFont& a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "N", new  ::QFont(a0), sipType_QFont, NULL);
}

void sipVH_QtOpenGL_3(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, bool a0)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "b", a0);
}

void* sipVH_QtOpenGL_2(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod)
{
    void* sipRes = 0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "");

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "V", &sipRes);

    return sipRes;
}

void sipVH_QtOpenGL_1(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod)
{
    sipCallProcedureMethod(sipGILState, sipErrorHandler, sipPySelf, sipMethod, "");
}

bool sipVH_QtOpenGL_0(sip_gilstate_t sipGILState, sipVirtErrorHandlerFunc sipErrorHandler, sipSimpleWrapper *sipPySelf, PyObject *sipMethod, const  ::QGLContext*a0)
{
    bool sipRes = 0;
    PyObject *sipResObj = sipCallMethod(0, sipMethod, "D", const_cast< ::QGLContext *>(a0), sipType_QGLContext, NULL);

    sipParseResultEx(sipGILState, sipErrorHandler, sipPySelf, sipMethod, sipResObj, "b", &sipRes);

    return sipRes;
}


/* Convert to a sub-class if possible. */
extern "C" {static const sipTypeDef *sipSubClass_QGLWidget(void **);}
static const sipTypeDef *sipSubClass_QGLWidget(void **sipCppRet)
{
     ::QObject *sipCpp = reinterpret_cast< ::QObject *>(*sipCppRet);
    const sipTypeDef *sipType;

#line 326 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qgl.sip"
    static struct class_graph {
        const char *name;
        sipTypeDef **type;
        int yes, no;
    } graph[] = {
        {sipName_QGLWidget, &sipType_QGLWidget, -1, 1},
    #if QT_VERSION >= 0x040600 && defined(SIP_FEATURE_PyQt_Deprecated_5_0)
        {sipName_QGLShaderProgram, &sipType_QGLShaderProgram, -1, 2},
    #else
        {0, 0, -1, 2},
    #endif
    #if QT_VERSION >= 0x040600 && defined(SIP_FEATURE_PyQt_Deprecated_5_0)
        {sipName_QGLShader, &sipType_QGLShader, -1, -1},
    #else
        {0, 0, -1, -1},
    #endif
    };
    
    int i = 0;
    
    sipType = NULL;
    
    do
    {
        struct class_graph *cg = &graph[i];
    
        if (cg->name != NULL && sipCpp->inherits(cg->name))
        {
            sipType = *cg->type;
            i = cg->yes;
        }
        else
            i = cg->no;
    }
    while (i >= 0);
#line 891 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

    return sipType;
}


extern "C" {static PyObject *slot_QGLShader_ShaderTypeBit___or__(PyObject *,PyObject *);}
static PyObject *slot_QGLShader_ShaderTypeBit___or__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLShader::ShaderTypeBit a0;
         ::QGLShader::ShaderType* a1;
        int a1State = 0;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "EJ1", sipType_QGLShader_ShaderTypeBit, &a0, sipType_QGLShader_ShaderType, &a1, &a1State))
        {
             ::QGLShader::ShaderType*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QGLShader::ShaderType((a0 | *a1));
            Py_END_ALLOW_THREADS
            sipReleaseType(a1,sipType_QGLShader_ShaderType,a1State);

            return sipConvertFromNewType(sipRes,sipType_QGLShader_ShaderType,NULL);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}

static sipPySlotDef slots_QGLShader_ShaderTypeBit[] = {
    {(void *)slot_QGLShader_ShaderTypeBit___or__, or_slot},
    {0, (sipPySlotType)0}
};



extern "C" {static PyObject *slot_QGLContext_BindOption___or__(PyObject *,PyObject *);}
static PyObject *slot_QGLContext_BindOption___or__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLContext::BindOption a0;
         ::QGLContext::BindOptions* a1;
        int a1State = 0;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "EJ1", sipType_QGLContext_BindOption, &a0, sipType_QGLContext_BindOptions, &a1, &a1State))
        {
             ::QGLContext::BindOptions*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QGLContext::BindOptions((a0 | *a1));
            Py_END_ALLOW_THREADS
            sipReleaseType(a1,sipType_QGLContext_BindOptions,a1State);

            return sipConvertFromNewType(sipRes,sipType_QGLContext_BindOptions,NULL);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}

static sipPySlotDef slots_QGLContext_BindOption[] = {
    {(void *)slot_QGLContext_BindOption___or__, or_slot},
    {0, (sipPySlotType)0}
};



extern "C" {static PyObject *slot_QGLFormat_OpenGLVersionFlag___or__(PyObject *,PyObject *);}
static PyObject *slot_QGLFormat_OpenGLVersionFlag___or__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLFormat::OpenGLVersionFlag a0;
         ::QGLFormat::OpenGLVersionFlags* a1;
        int a1State = 0;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "EJ1", sipType_QGLFormat_OpenGLVersionFlag, &a0, sipType_QGLFormat_OpenGLVersionFlags, &a1, &a1State))
        {
             ::QGLFormat::OpenGLVersionFlags*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QGLFormat::OpenGLVersionFlags((a0 | *a1));
            Py_END_ALLOW_THREADS
            sipReleaseType(a1,sipType_QGLFormat_OpenGLVersionFlags,a1State);

            return sipConvertFromNewType(sipRes,sipType_QGLFormat_OpenGLVersionFlags,NULL);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}

static sipPySlotDef slots_QGLFormat_OpenGLVersionFlag[] = {
    {(void *)slot_QGLFormat_OpenGLVersionFlag___or__, or_slot},
    {0, (sipPySlotType)0}
};



extern "C" {static PyObject *slot_QGL_FormatOption___or__(PyObject *,PyObject *);}
static PyObject *slot_QGL_FormatOption___or__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGL::FormatOption a0;
         ::QGL::FormatOptions* a1;
        int a1State = 0;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "EJ1", sipType_QGL_FormatOption, &a0, sipType_QGL_FormatOptions, &a1, &a1State))
        {
             ::QGL::FormatOptions*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QGL::FormatOptions((a0 | *a1));
            Py_END_ALLOW_THREADS
            sipReleaseType(a1,sipType_QGL_FormatOptions,a1State);

            return sipConvertFromNewType(sipRes,sipType_QGL_FormatOptions,NULL);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}

static sipPySlotDef slots_QGL_FormatOption[] = {
    {(void *)slot_QGL_FormatOption___or__, or_slot},
    {0, (sipPySlotType)0}
};

static sipEnumTypeDef enumTypes[] = {
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QGLShader__ShaderTypeBit, {0}, 0}, sipNameNr_ShaderTypeBit, 19, slots_QGLShader_ShaderTypeBit},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QGLFramebufferObject__Attachment, {0}, 0}, sipNameNr_Attachment, 15, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QGLBuffer__UsagePattern, {0}, 0}, sipNameNr_UsagePattern, 3, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QGLBuffer__Type, {0}, 0}, sipNameNr_Type, 3, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QGLBuffer__Access, {0}, 0}, sipNameNr_Access, 3, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QGLContext__BindOption, {0}, 0}, sipNameNr_BindOption, 8, slots_QGLContext_BindOption},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QGLFormat__OpenGLContextProfile, {0}, 0}, sipNameNr_OpenGLContextProfile, 11, NULL},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QGLFormat__OpenGLVersionFlag, {0}, 0}, sipNameNr_OpenGLVersionFlag, 11, slots_QGLFormat_OpenGLVersionFlag},
    {{-1, 0, 0, SIP_TYPE_ENUM, sipNameNr_QGL__FormatOption, {0}, 0}, sipNameNr_FormatOption, 0, slots_QGL_FormatOption},
};


/*
 * This defines each type in this module.
 */
sipTypeDef *sipExportedTypes_QtOpenGL[] = {
    &sipTypeDef_QtOpenGL_QGL.ctd_base,
    &enumTypes[8].etd_base,
    &sipTypeDef_QtOpenGL_QGL_FormatOptions.ctd_base,
    &sipTypeDef_QtOpenGL_QGLBuffer.ctd_base,
    &enumTypes[4].etd_base,
    &enumTypes[3].etd_base,
    &enumTypes[2].etd_base,
    &sipTypeDef_QtOpenGL_QGLColormap.ctd_base,
    &sipTypeDef_QtOpenGL_QGLContext.ctd_base,
    &enumTypes[5].etd_base,
    &sipTypeDef_QtOpenGL_QGLContext_BindOptions.ctd_base,
    &sipTypeDef_QtOpenGL_QGLFormat.ctd_base,
    &enumTypes[6].etd_base,
    &enumTypes[7].etd_base,
    &sipTypeDef_QtOpenGL_QGLFormat_OpenGLVersionFlags.ctd_base,
    &sipTypeDef_QtOpenGL_QGLFramebufferObject.ctd_base,
    &enumTypes[1].etd_base,
    &sipTypeDef_QtOpenGL_QGLFramebufferObjectFormat.ctd_base,
    &sipTypeDef_QtOpenGL_QGLPixelBuffer.ctd_base,
    &sipTypeDef_QtOpenGL_QGLShader.ctd_base,
    &sipTypeDef_QtOpenGL_QGLShader_ShaderType.ctd_base,
    &enumTypes[0].etd_base,
    &sipTypeDef_QtOpenGL_QGLShaderProgram.ctd_base,
    &sipTypeDef_QtOpenGL_QGLWidget.ctd_base,
    &sipTypeDef_QtOpenGL_QList_0101QGLShader.mtd_base,
};


/* This defines the types that this module needs to import from QtCore. */
sipImportedTypeDef sipImportedTypes_QtOpenGL_QtCore[] = {
    {"QByteArray"},
    {"QChildEvent"},
    {"QEvent"},
    {"QObject"},
    {"QPoint"},
    {"QPointF"},
    {"QRect"},
    {"QRectF"},
    {"QSize"},
    {"QSizeF"},
    {"QString"},
    {"QTimerEvent"},
    {"QVariant"},
    {"Qt::InputMethodQuery"},
    {"Qt::WindowFlags"},
    {NULL}
};


/* This defines the types that this module needs to import from QtGui. */
sipImportedTypeDef sipImportedTypes_QtOpenGL_QtGui[] = {
    {"QActionEvent"},
    {"QCloseEvent"},
    {"QColor"},
    {"QContextMenuEvent"},
    {"QDragEnterEvent"},
    {"QDragLeaveEvent"},
    {"QDragMoveEvent"},
    {"QDropEvent"},
    {"QFocusEvent"},
    {"QFont"},
    {"QHideEvent"},
    {"QImage"},
    {"QInputMethodEvent"},
    {"QKeyEvent"},
    {"QMatrix2x2"},
    {"QMatrix2x3"},
    {"QMatrix2x4"},
    {"QMatrix3x2"},
    {"QMatrix3x3"},
    {"QMatrix3x4"},
    {"QMatrix4x2"},
    {"QMatrix4x3"},
    {"QMatrix4x4"},
    {"QMouseEvent"},
    {"QMoveEvent"},
    {"QPaintDevice"},
    {"QPaintDevice::PaintDeviceMetric"},
    {"QPaintEngine"},
    {"QPaintEngine::Type"},
    {"QPaintEvent"},
    {"QPalette"},
    {"QPixmap"},
    {"QResizeEvent"},
    {"QShowEvent"},
    {"QTabletEvent"},
    {"QTransform"},
    {"QVector2D"},
    {"QVector3D"},
    {"QVector4D"},
    {"QWheelEvent"},
    {"QWidget"},
    {NULL}
};


/* This defines the modules that this module needs to import. */
static sipImportedModuleDef importsTable[] = {
    {"PyQt4.QtCore", sipImportedTypes_QtOpenGL_QtCore, NULL, NULL},
    {"PyQt4.QtGui", sipImportedTypes_QtOpenGL_QtGui, NULL, NULL},
    {NULL, NULL, NULL, NULL}
};


/* This defines the class sub-convertors that this module defines. */
static sipSubClassConvertorDef convertorsTable[] = {
    {sipSubClass_QGLWidget, {3, 0, 0}, NULL},
    {NULL, {0, 0, 0}, NULL}
};


/* This defines this module. */
sipExportedModuleDef sipModuleAPI_QtOpenGL = {
    0,
    SIP_API_MINOR_NR,
    sipNameNr_PyQt4_QtOpenGL,
    0,
    sipStrings_QtOpenGL,
    importsTable,
    NULL,
    25,
    sipExportedTypes_QtOpenGL,
    NULL,
    0,
    NULL,
    0,
    NULL,
    NULL,
    convertorsTable,
    {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL},
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL
};


/* The SIP API and the APIs of any imported modules. */
const sipAPIDef *sipAPI_QtOpenGL;

sip_qt_metaobject_func sip_QtOpenGL_qt_metaobject;
sip_qt_metacall_func sip_QtOpenGL_qt_metacall;
sip_qt_metacast_func sip_QtOpenGL_qt_metacast;


/* The Python module initialisation function. */
#if PY_MAJOR_VERSION >= 3
#define SIP_MODULE_ENTRY        PyInit_QtOpenGL
#define SIP_MODULE_TYPE         PyObject *
#define SIP_MODULE_DISCARD(r)   Py_DECREF(r)
#define SIP_MODULE_RETURN(r)    return (r)
#else
#define SIP_MODULE_ENTRY        initQtOpenGL
#define SIP_MODULE_TYPE         void
#define SIP_MODULE_DISCARD(r)
#define SIP_MODULE_RETURN(r)    return
#endif

#if defined(SIP_STATIC_MODULE)
extern "C" SIP_MODULE_TYPE SIP_MODULE_ENTRY()
#else
PyMODINIT_FUNC SIP_MODULE_ENTRY()
#endif
{
    static PyMethodDef sip_methods[] = {
        {0, 0, 0, 0}
    };

#if PY_MAJOR_VERSION >= 3
    static PyModuleDef sip_module_def = {
        PyModuleDef_HEAD_INIT,
        "PyQt4.QtOpenGL",
        NULL,
        -1,
        sip_methods,
        NULL,
        NULL,
        NULL,
        NULL
    };
#endif

    PyObject *sipModule, *sipModuleDict;
    PyObject *sip_sipmod, *sip_capiobj;

    /* Initialise the module and get it's dictionary. */
#if PY_MAJOR_VERSION >= 3
    sipModule = PyModule_Create(&sip_module_def);
#elif PY_VERSION_HEX >= 0x02050000
    sipModule = Py_InitModule(sipName_PyQt4_QtOpenGL, sip_methods);
#else
    sipModule = Py_InitModule(const_cast<char *>(sipName_PyQt4_QtOpenGL), sip_methods);
#endif

    if (sipModule == NULL)
        SIP_MODULE_RETURN(NULL);

    sipModuleDict = PyModule_GetDict(sipModule);

    /* Get the SIP module's API. */
#if PY_VERSION_HEX >= 0x02050000
    sip_sipmod = PyImport_ImportModule("PyQt4.sip");
#else
    sip_sipmod = PyImport_ImportModule(const_cast<char *>("PyQt4.sip"));
#endif

    if (sip_sipmod == NULL)
    {
        SIP_MODULE_DISCARD(sipModule);
        SIP_MODULE_RETURN(NULL);
    }

    sip_capiobj = PyDict_GetItemString(PyModule_GetDict(sip_sipmod), "_C_API");
    Py_DECREF(sip_sipmod);

#if defined(SIP_USE_PYCAPSULE)
    if (sip_capiobj == NULL || !PyCapsule_CheckExact(sip_capiobj))
#else
    if (sip_capiobj == NULL || !PyCObject_Check(sip_capiobj))
#endif
    {
        SIP_MODULE_DISCARD(sipModule);
        SIP_MODULE_RETURN(NULL);
    }

#if defined(SIP_USE_PYCAPSULE)
    sipAPI_QtOpenGL = reinterpret_cast<const sipAPIDef *>(PyCapsule_GetPointer(sip_capiobj, "PyQt4.sip._C_API"));
#else
    sipAPI_QtOpenGL = reinterpret_cast<const sipAPIDef *>(PyCObject_AsVoidPtr(sip_capiobj));
#endif

#if defined(SIP_USE_PYCAPSULE)
    if (sipAPI_QtOpenGL == NULL)
    {
        SIP_MODULE_DISCARD(sipModule);
        SIP_MODULE_RETURN(NULL);
    }
#endif

    /* Export the module and publish it's API. */
    if (sipExportModule(&sipModuleAPI_QtOpenGL,SIP_API_MAJOR_NR,SIP_API_MINOR_NR,0) < 0)
    {
        SIP_MODULE_DISCARD(sipModule);
        SIP_MODULE_RETURN(0);
    }

    sip_QtOpenGL_qt_metaobject = (sip_qt_metaobject_func)sipImportSymbol("qtcore_qt_metaobject");
    sip_QtOpenGL_qt_metacall = (sip_qt_metacall_func)sipImportSymbol("qtcore_qt_metacall");
    sip_QtOpenGL_qt_metacast = (sip_qt_metacast_func)sipImportSymbol("qtcore_qt_metacast");

    if (!sip_QtOpenGL_qt_metacast)
        Py_FatalError("Unable to import qtcore_qt_metacast");

    /* Initialise the module now all its dependencies have been set up. */
    if (sipInitModule(&sipModuleAPI_QtOpenGL,sipModuleDict) < 0)
    {
        SIP_MODULE_DISCARD(sipModule);
        SIP_MODULE_RETURN(0);
    }

    SIP_MODULE_RETURN(sipModule);
}

#line 115 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 1337 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

#line 29 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qglshaderprogram.sip"
#include <qglshaderprogram.h>
#line 1341 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"


extern "C" {static void assign_QList_0101QGLShader(void *, SIP_SSIZE_T, void *);}
static void assign_QList_0101QGLShader(void *sipDst, SIP_SSIZE_T sipDstIdx, void *sipSrc)
{
    reinterpret_cast<QList< ::QGLShader*> *>(sipDst)[sipDstIdx] = *reinterpret_cast<QList< ::QGLShader*> *>(sipSrc);
}


extern "C" {static void *array_QList_0101QGLShader(SIP_SSIZE_T);}
static void *array_QList_0101QGLShader(SIP_SSIZE_T sipNrElem)
{
    return new QList< ::QGLShader*>[sipNrElem];
}


extern "C" {static void *copy_QList_0101QGLShader(const void *, SIP_SSIZE_T);}
static void *copy_QList_0101QGLShader(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new QList< ::QGLShader*>(reinterpret_cast<const QList< ::QGLShader*> *>(sipSrc)[sipSrcIdx]);
}


/* Call the mapped type's destructor. */
extern "C" {static void release_QList_0101QGLShader(void *, int);}
static void release_QList_0101QGLShader(void *ptr, int)
{
    Py_BEGIN_ALLOW_THREADS
    delete reinterpret_cast<QList< ::QGLShader*> *>(ptr);
    Py_END_ALLOW_THREADS
}



extern "C" {static int convertTo_QList_0101QGLShader(PyObject *, void **, int *, PyObject *);}
static int convertTo_QList_0101QGLShader(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
    QList< ::QGLShader*> **sipCppPtr = reinterpret_cast<QList< ::QGLShader*> **>(sipCppPtrV);

#line 145 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qlist.sip"
    SIP_SSIZE_T len;

    // Check the type if that is all that is required.
    if (sipIsErr == NULL)
    {
        if (!PySequence_Check(sipPy) || (len = PySequence_Size(sipPy)) < 0)
            return 0;

        for (SIP_SSIZE_T i = 0; i < len; ++i)
        {
            PyObject *itm = PySequence_ITEM(sipPy, i);
            bool ok = (itm && sipCanConvertToType(itm, sipType_QGLShader, 0));

            Py_XDECREF(itm);

            if (!ok)
                return 0;
        }

        return 1;
    }

    QList<QGLShader *> *ql = new QList<QGLShader *>;
    len = PySequence_Size(sipPy);
 
    for (SIP_SSIZE_T i = 0; i < len; ++i)
    {
        PyObject *itm = PySequence_ITEM(sipPy, i);
        QGLShader *t = reinterpret_cast<QGLShader *>(sipConvertToType(itm, sipType_QGLShader, sipTransferObj, 0, 0, sipIsErr));

        Py_DECREF(itm);
 
        if (*sipIsErr)
        {
            delete ql;
            return 0;
        }

        ql->append(t);
    }
 
    *sipCppPtr = ql;
 
    return sipGetState(sipTransferObj);
#line 1426 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
}


extern "C" {static PyObject *convertFrom_QList_0101QGLShader(void *, PyObject *);}
static PyObject *convertFrom_QList_0101QGLShader(void *sipCppV, PyObject *sipTransferObj)
{
   QList< ::QGLShader*> *sipCpp = reinterpret_cast<QList< ::QGLShader*> *>(sipCppV);

#line 119 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qlist.sip"
    // Create the list.
    PyObject *l;

    if ((l = PyList_New(sipCpp->size())) == NULL)
        return NULL;

    // Set the list elements.
    for (int i = 0; i < sipCpp->size(); ++i)
    {
        QGLShader *t = sipCpp->at(i);
        PyObject *tobj;

        // The explicit (void *) cast allows QGLShader to be const.
        if ((tobj = sipConvertFromType((void *)t, sipType_QGLShader, sipTransferObj)) == NULL)
        {
            Py_DECREF(l);
            return NULL;
        }

        PyList_SET_ITEM(l, i, tobj);
    }

    return l;
#line 1459 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
}


sipMappedTypeDef sipTypeDef_QtOpenGL_QList_0101QGLShader = {
    {
        -1,
        0,
        0,
        SIP_TYPE_MAPPED,
        sipNameNr_1811,     /* QList<QGLShader*> */
        {0},
        0
    },
    {
        -1,
        {0, 0, 1},
        0, 0,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
    },
    assign_QList_0101QGLShader,
    array_QList_0101QGLShader,
    copy_QList_0101QGLShader,
    release_QList_0101QGLShader,
    convertTo_QList_0101QGLShader,
    convertFrom_QList_0101QGLShader
};

#line 75 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qglshaderprogram.sip"
#include <qglshaderprogram.h>
#line 1491 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

#line 29 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qobject.sip"
#include <qobject.h>
#line 1495 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 225 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qgl.sip"
#include <qgl.h>
#line 1498 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 34 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qvector2d.sip"
#include <qvector2d.h>
#line 1501 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 34 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qvector3d.sip"
#include <qvector3d.h>
#line 1504 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 34 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qvector4d.sip"
#include <qvector4d.h>
#line 1507 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qcolor.sip"
#include <qcolor.h>
#line 1510 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qpoint.sip"
#include <qpoint.h>
#line 1513 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 110 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qpoint.sip"
#include <qpoint.h>
#line 1516 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qsize.sip"
#include <qsize.h>
#line 1519 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 103 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qsize.sip"
#include <qsize.h>
#line 1522 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 1088 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qgenericmatrix.sip"
#include <qgenericmatrix.h>
#line 1525 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 940 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qgenericmatrix.sip"
#include <qgenericmatrix.h>
#line 1528 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 792 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qgenericmatrix.sip"
#include <qgenericmatrix.h>
#line 1531 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 641 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qgenericmatrix.sip"
#include <qgenericmatrix.h>
#line 1534 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 490 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qgenericmatrix.sip"
#include <qgenericmatrix.h>
#line 1537 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 336 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qgenericmatrix.sip"
#include <qgenericmatrix.h>
#line 1540 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 182 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qgenericmatrix.sip"
#include <qgenericmatrix.h>
#line 1543 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qgenericmatrix.sip"
#include <qgenericmatrix.h>
#line 1546 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 34 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qmatrix4x4.sip"
#include <qmatrix4x4.h>
#line 1549 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 34 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qtransform.sip"
#include <qtransform.h>
#line 1552 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 32 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 1555 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 27 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 1558 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 29 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qglshaderprogram.sip"
#include <qglshaderprogram.h>
#line 1561 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 115 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 1564 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 29 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qglshaderprogram.sip"
#include <qglshaderprogram.h>
#line 1567 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 1570 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 368 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 1573 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 351 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 1576 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 265 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 1579 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 1582 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 1585 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 115 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 1588 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qthread.sip"
#include <qthread.h>
#line 1591 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qregexp.sip"
#include <qregexp.h>
#line 1594 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 1597 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"


class sipQGLShaderProgram : public  ::QGLShaderProgram
{
public:
    sipQGLShaderProgram( ::QObject*);
    sipQGLShaderProgram(const  ::QGLContext*, ::QObject*);
    virtual ~sipQGLShaderProgram();

    int qt_metacall(QMetaObject::Call,int,void **);
    void *qt_metacast(const char *);
    const QMetaObject *metaObject() const;

    /*
     * There is a public method for every protected method visible from
     * this class.
     */
     ::QObject* sipProtect_sender() const;
    int sipProtect_receivers(const char*) const;
    void sipProtectVirt_timerEvent(bool, ::QTimerEvent*);
    void sipProtectVirt_childEvent(bool, ::QChildEvent*);
    void sipProtectVirt_customEvent(bool, ::QEvent*);
    void sipProtectVirt_connectNotify(bool,const char*);
    void sipProtectVirt_disconnectNotify(bool,const char*);
    int sipProtect_senderSignalIndex() const;

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
    bool link();
    bool event( ::QEvent*);
    bool eventFilter( ::QObject*, ::QEvent*);
    void timerEvent( ::QTimerEvent*);
    void childEvent( ::QChildEvent*);
    void customEvent( ::QEvent*);
    void connectNotify(const char*);
    void disconnectNotify(const char*);

public:
    sipSimpleWrapper *sipPySelf;

private:
    sipQGLShaderProgram(const sipQGLShaderProgram &);
    sipQGLShaderProgram &operator = (const sipQGLShaderProgram &);

    char sipPyMethods[8];
};

sipQGLShaderProgram::sipQGLShaderProgram( ::QObject*a0):  ::QGLShaderProgram(a0), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQGLShaderProgram::sipQGLShaderProgram(const  ::QGLContext*a0, ::QObject*a1):  ::QGLShaderProgram(a0,a1), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQGLShaderProgram::~sipQGLShaderProgram()
{
    sipInstanceDestroyedEx(&sipPySelf);
}

const QMetaObject *sipQGLShaderProgram::metaObject() const
{
    return sip_QtOpenGL_qt_metaobject(sipPySelf,sipType_QGLShaderProgram);
}

int sipQGLShaderProgram::qt_metacall(QMetaObject::Call _c,int _id,void **_a)
{
    _id =  ::QGLShaderProgram::qt_metacall(_c,_id,_a);

    if (_id >= 0)
        _id = sip_QtOpenGL_qt_metacall(sipPySelf,sipType_QGLShaderProgram,_c,_id,_a);

    return _id;
}

void *sipQGLShaderProgram::qt_metacast(const char *_clname)
{
    return (sip_QtOpenGL_qt_metacast(sipPySelf, sipType_QGLShaderProgram, _clname)) ? this :  ::QGLShaderProgram::qt_metacast(_clname);
}

bool sipQGLShaderProgram::link()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[0],sipPySelf,NULL,sipName_link);

    if (!sipMeth)
        return  ::QGLShaderProgram::link();

    extern bool sipVH_QtOpenGL_38(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH_QtOpenGL_38(sipGILState, 0, sipPySelf, sipMeth);
}

bool sipQGLShaderProgram::event( ::QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[1],sipPySelf,NULL,sipName_event);

    if (!sipMeth)
        return  ::QGLShaderProgram::event(a0);

    extern bool sipVH_QtOpenGL_32(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QEvent*);

    return sipVH_QtOpenGL_32(sipGILState, 0, sipPySelf, sipMeth, a0);
}

bool sipQGLShaderProgram::eventFilter( ::QObject*a0, ::QEvent*a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[2],sipPySelf,NULL,sipName_eventFilter);

    if (!sipMeth)
        return  ::QGLShaderProgram::eventFilter(a0,a1);

    extern bool sipVH_QtOpenGL_33(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QObject*, ::QEvent*);

    return sipVH_QtOpenGL_33(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

void sipQGLShaderProgram::timerEvent( ::QTimerEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[3],sipPySelf,NULL,sipName_timerEvent);

    if (!sipMeth)
    {
         ::QGLShaderProgram::timerEvent(a0);
        return;
    }

    extern void sipVH_QtOpenGL_34(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QTimerEvent*);

    sipVH_QtOpenGL_34(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLShaderProgram::childEvent( ::QChildEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[4],sipPySelf,NULL,sipName_childEvent);

    if (!sipMeth)
    {
         ::QGLShaderProgram::childEvent(a0);
        return;
    }

    extern void sipVH_QtOpenGL_35(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QChildEvent*);

    sipVH_QtOpenGL_35(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLShaderProgram::customEvent( ::QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[5],sipPySelf,NULL,sipName_customEvent);

    if (!sipMeth)
    {
         ::QGLShaderProgram::customEvent(a0);
        return;
    }

    extern void sipVH_QtOpenGL_9(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QEvent*);

    sipVH_QtOpenGL_9(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLShaderProgram::connectNotify(const char*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[6],sipPySelf,NULL,sipName_connectNotify);

    if (!sipMeth)
    {
         ::QGLShaderProgram::connectNotify(a0);
        return;
    }

    extern void sipVH_QtOpenGL_36(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const char*);

    sipVH_QtOpenGL_36(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLShaderProgram::disconnectNotify(const char*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[7],sipPySelf,NULL,sipName_disconnectNotify);

    if (!sipMeth)
    {
         ::QGLShaderProgram::disconnectNotify(a0);
        return;
    }

    extern void sipVH_QtOpenGL_36(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const char*);

    sipVH_QtOpenGL_36(sipGILState, 0, sipPySelf, sipMeth, a0);
}

 ::QObject* sipQGLShaderProgram::sipProtect_sender() const
{
    return  ::QObject::sender();
}

int sipQGLShaderProgram::sipProtect_receivers(const char*a0) const
{
    return  ::QObject::receivers(a0);
}

void sipQGLShaderProgram::sipProtectVirt_timerEvent(bool sipSelfWasArg, ::QTimerEvent*a0)
{
    (sipSelfWasArg ?  ::QObject::timerEvent(a0) : timerEvent(a0));
}

void sipQGLShaderProgram::sipProtectVirt_childEvent(bool sipSelfWasArg, ::QChildEvent*a0)
{
    (sipSelfWasArg ?  ::QObject::childEvent(a0) : childEvent(a0));
}

void sipQGLShaderProgram::sipProtectVirt_customEvent(bool sipSelfWasArg, ::QEvent*a0)
{
    (sipSelfWasArg ?  ::QObject::customEvent(a0) : customEvent(a0));
}

void sipQGLShaderProgram::sipProtectVirt_connectNotify(bool sipSelfWasArg,const char*a0)
{
    (sipSelfWasArg ?  ::QObject::connectNotify(a0) : connectNotify(a0));
}

void sipQGLShaderProgram::sipProtectVirt_disconnectNotify(bool sipSelfWasArg,const char*a0)
{
    (sipSelfWasArg ?  ::QObject::disconnectNotify(a0) : disconnectNotify(a0));
}

int sipQGLShaderProgram::sipProtect_senderSignalIndex() const
{
    return  ::QObject::senderSignalIndex();
}


PyDoc_STRVAR(doc_QGLShaderProgram_sender, "sender(self) -> QObject");

extern "C" {static PyObject *meth_QGLShaderProgram_sender(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLShaderProgram_sender(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQGLShaderProgram *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QGLShaderProgram, &sipCpp))
        {
             ::QObject*sipRes = 0;

#line 678 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qobject.sip"
        typedef QObject *(*helper_func)(QObject *);
        
        static helper_func helper = 0;
        
        if (!helper)
        {
            helper = (helper_func)sipImportSymbol("qpycore_qobject_sender");
            Q_ASSERT(helper);
        }
        
        // sender() must be called without the GIL to avoid possible deadlocks between
        // the GIL and Qt's internal thread data mutex.
        
        Py_BEGIN_ALLOW_THREADS
        
        #if defined(SIP_PROTECTED_IS_PUBLIC)
        sipRes = sipCpp->sender();
        #else
        sipRes = sipCpp->sipProtect_sender();
        #endif
        
        Py_END_ALLOW_THREADS
        
        sipRes = helper(sipRes);
#line 1899 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

            return sipConvertFromType(sipRes,sipType_QObject,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShaderProgram, sipName_sender, doc_QGLShaderProgram_sender);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShaderProgram_receivers, "receivers(self, QT_SIGNAL) -> int");

extern "C" {static PyObject *meth_QGLShaderProgram_receivers(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLShaderProgram_receivers(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        PyObject * a0;
        const sipQGLShaderProgram *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BP0", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0))
        {
            int sipRes = 0;
            sipErrorState sipError = sipErrorNone;

#line 706 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qobject.sip"
        // We need to take into account any proxies for Python signals. Import the
        // helpers if it hasn't already been done.
        typedef const char *(*pyqt4_get_signal_t)(PyObject *);
        typedef int (*receivers_helper_func)(QObject *, const char *, int);
        
        static pyqt4_get_signal_t pyqt4_get_signal = 0;
        static receivers_helper_func receivers_helper = 0;
        
        if (!pyqt4_get_signal)
        {
            pyqt4_get_signal = (pyqt4_get_signal_t)sipImportSymbol("pyqt4_get_signal");
            Q_ASSERT(pyqt4_get_signal);
        }
        
        if (!receivers_helper)
        {
            receivers_helper = (receivers_helper_func)sipImportSymbol("qpycore_qobject_receivers");
            Q_ASSERT(receivers_helper);
        }
        
        // PyQt5: Get rid of the const casts.
        const char *sig = pyqt4_get_signal(a0);
            
        if (sig)
        {
        #if defined(SIP_PROTECTED_IS_PUBLIC)
            sipRes = receivers_helper(const_cast<QObject *>(sipCpp), sig, sipCpp->receivers(sig));
        #else
            sipRes = receivers_helper(const_cast<QObject *>(static_cast<const QObject *>(sipCpp)), sig, sipCpp->sipProtect_receivers(sig));
        #endif
        }
        else
        {
            sipError = sipBadCallableArg(0, a0);
        }
#line 1965 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            return SIPLong_FromLong(sipRes);
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShaderProgram, sipName_receivers, doc_QGLShaderProgram_receivers);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShaderProgram_timerEvent, "timerEvent(self, QTimerEvent)");

extern "C" {static PyObject *meth_QGLShaderProgram_timerEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLShaderProgram_timerEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QTimerEvent* a0;
        sipQGLShaderProgram *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGLShaderProgram, &sipCpp, sipType_QTimerEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_timerEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShaderProgram, sipName_timerEvent, doc_QGLShaderProgram_timerEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShaderProgram_childEvent, "childEvent(self, QChildEvent)");

extern "C" {static PyObject *meth_QGLShaderProgram_childEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLShaderProgram_childEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QChildEvent* a0;
        sipQGLShaderProgram *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGLShaderProgram, &sipCpp, sipType_QChildEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_childEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShaderProgram, sipName_childEvent, doc_QGLShaderProgram_childEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShaderProgram_customEvent, "customEvent(self, QEvent)");

extern "C" {static PyObject *meth_QGLShaderProgram_customEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLShaderProgram_customEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QEvent* a0;
        sipQGLShaderProgram *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGLShaderProgram, &sipCpp, sipType_QEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_customEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShaderProgram, sipName_customEvent, doc_QGLShaderProgram_customEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShaderProgram_connectNotify, "connectNotify(self, QT_SIGNAL)");

extern "C" {static PyObject *meth_QGLShaderProgram_connectNotify(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLShaderProgram_connectNotify(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        PyObject * a0;
        sipQGLShaderProgram *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BP0", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0))
        {
            sipErrorState sipError = sipErrorNone;

#line 752 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qobject.sip"
        typedef const char *(*pyqt4_get_signal_t)(PyObject *);
        
        static pyqt4_get_signal_t pyqt4_get_signal = 0;
        
        if (!pyqt4_get_signal)
        {
            pyqt4_get_signal = (pyqt4_get_signal_t)sipImportSymbol("pyqt4_get_signal");
            Q_ASSERT(pyqt4_get_signal);
        }
        
        const char *sig = pyqt4_get_signal(a0);
            
        if (sig)
        {
        #if defined(SIP_PROTECTED_IS_PUBLIC)
            (sipSelfWasArg ? sipCpp->QObject::connectNotify(sig) : sipCpp->connectNotify(sig));
        #else
            sipCpp->sipProtectVirt_connectNotify(sipSelfWasArg, sig);
        #endif
        }
        else
        {
            sipError = sipBadCallableArg(0, a0);
        }
#line 2121 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShaderProgram, sipName_connectNotify, doc_QGLShaderProgram_connectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShaderProgram_disconnectNotify, "disconnectNotify(self, QT_SIGNAL)");

extern "C" {static PyObject *meth_QGLShaderProgram_disconnectNotify(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLShaderProgram_disconnectNotify(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        PyObject * a0;
        sipQGLShaderProgram *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BP0", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0))
        {
            sipErrorState sipError = sipErrorNone;

#line 785 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qobject.sip"
        typedef const char *(*pyqt4_get_signal_t)(PyObject *);
        
        static pyqt4_get_signal_t pyqt4_get_signal = 0;
        
        if (!pyqt4_get_signal)
        {
            pyqt4_get_signal = (pyqt4_get_signal_t)sipImportSymbol("pyqt4_get_signal");
            Q_ASSERT(pyqt4_get_signal);
        }
        
        const char *sig = pyqt4_get_signal(a0);
            
        if (sig)
        {
        #if defined(SIP_PROTECTED_IS_PUBLIC)
            (sipSelfWasArg ? sipCpp->QObject::disconnectNotify(sig) : sipCpp->disconnectNotify(sig));
        #else
            sipCpp->sipProtectVirt_disconnectNotify(sipSelfWasArg, sig);
        #endif
        }
        else
        {
            sipError = sipBadCallableArg(0, a0);
        }
#line 2185 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShaderProgram, sipName_disconnectNotify, doc_QGLShaderProgram_disconnectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShaderProgram_senderSignalIndex, "senderSignalIndex(self) -> int");

extern "C" {static PyObject *meth_QGLShaderProgram_senderSignalIndex(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLShaderProgram_senderSignalIndex(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQGLShaderProgram *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QGLShaderProgram, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_senderSignalIndex();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShaderProgram, sipName_senderSignalIndex, doc_QGLShaderProgram_senderSignalIndex);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShaderProgram_addShader, "addShader(self, QGLShader) -> bool");

extern "C" {static PyObject *meth_QGLShaderProgram_addShader(PyObject *, PyObject *);}
static PyObject *meth_QGLShaderProgram_addShader(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLShader* a0;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ8", &sipSelf, sipType_QGLShaderProgram, &sipCpp, sipType_QGLShader, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->addShader(a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShaderProgram, sipName_addShader, doc_QGLShaderProgram_addShader);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShaderProgram_removeShader, "removeShader(self, QGLShader)");

extern "C" {static PyObject *meth_QGLShaderProgram_removeShader(PyObject *, PyObject *);}
static PyObject *meth_QGLShaderProgram_removeShader(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLShader* a0;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ8", &sipSelf, sipType_QGLShaderProgram, &sipCpp, sipType_QGLShader, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->removeShader(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShaderProgram, sipName_removeShader, doc_QGLShaderProgram_removeShader);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShaderProgram_shaders, "shaders(self) -> object");

extern "C" {static PyObject *meth_QGLShaderProgram_shaders(PyObject *, PyObject *);}
static PyObject *meth_QGLShaderProgram_shaders(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLShaderProgram, &sipCpp))
        {
            QList< ::QGLShader*>*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new QList< ::QGLShader*>(sipCpp->shaders());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QList_0101QGLShader,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShaderProgram, sipName_shaders, doc_QGLShaderProgram_shaders);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShaderProgram_addShaderFromSourceCode, "addShaderFromSourceCode(self, QGLShader.ShaderType, Union[QByteArray, bytes, bytearray]) -> bool\n"
"addShaderFromSourceCode(self, QGLShader.ShaderType, str) -> bool");

extern "C" {static PyObject *meth_QGLShaderProgram_addShaderFromSourceCode(PyObject *, PyObject *);}
static PyObject *meth_QGLShaderProgram_addShaderFromSourceCode(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLShader::ShaderType* a0;
        int a0State = 0;
        const  ::QByteArray* a1;
        int a1State = 0;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1J1", &sipSelf, sipType_QGLShaderProgram, &sipCpp, sipType_QGLShader_ShaderType, &a0, &a0State, sipType_QByteArray, &a1, &a1State))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->addShaderFromSourceCode(*a0,*a1);
            Py_END_ALLOW_THREADS
            sipReleaseType(a0,sipType_QGLShader_ShaderType,a0State);
            sipReleaseType(const_cast< ::QByteArray *>(a1),sipType_QByteArray,a1State);

            return PyBool_FromLong(sipRes);
        }
    }

    {
         ::QGLShader::ShaderType* a0;
        int a0State = 0;
        const  ::QString* a1;
        int a1State = 0;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1J1", &sipSelf, sipType_QGLShaderProgram, &sipCpp, sipType_QGLShader_ShaderType, &a0, &a0State, sipType_QString,&a1, &a1State))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->addShaderFromSourceCode(*a0,*a1);
            Py_END_ALLOW_THREADS
            sipReleaseType(a0,sipType_QGLShader_ShaderType,a0State);
            sipReleaseType(const_cast< ::QString *>(a1),sipType_QString,a1State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShaderProgram, sipName_addShaderFromSourceCode, doc_QGLShaderProgram_addShaderFromSourceCode);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShaderProgram_addShaderFromSourceFile, "addShaderFromSourceFile(self, QGLShader.ShaderType, str) -> bool");

extern "C" {static PyObject *meth_QGLShaderProgram_addShaderFromSourceFile(PyObject *, PyObject *);}
static PyObject *meth_QGLShaderProgram_addShaderFromSourceFile(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLShader::ShaderType* a0;
        int a0State = 0;
        const  ::QString* a1;
        int a1State = 0;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1J1", &sipSelf, sipType_QGLShaderProgram, &sipCpp, sipType_QGLShader_ShaderType, &a0, &a0State, sipType_QString,&a1, &a1State))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->addShaderFromSourceFile(*a0,*a1);
            Py_END_ALLOW_THREADS
            sipReleaseType(a0,sipType_QGLShader_ShaderType,a0State);
            sipReleaseType(const_cast< ::QString *>(a1),sipType_QString,a1State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShaderProgram, sipName_addShaderFromSourceFile, doc_QGLShaderProgram_addShaderFromSourceFile);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShaderProgram_removeAllShaders, "removeAllShaders(self)");

extern "C" {static PyObject *meth_QGLShaderProgram_removeAllShaders(PyObject *, PyObject *);}
static PyObject *meth_QGLShaderProgram_removeAllShaders(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLShaderProgram, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->removeAllShaders();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShaderProgram, sipName_removeAllShaders, doc_QGLShaderProgram_removeAllShaders);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShaderProgram_link, "link(self) -> bool");

extern "C" {static PyObject *meth_QGLShaderProgram_link(PyObject *, PyObject *);}
static PyObject *meth_QGLShaderProgram_link(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLShaderProgram, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp-> ::QGLShaderProgram::link() : sipCpp->link());
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShaderProgram, sipName_link, doc_QGLShaderProgram_link);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShaderProgram_isLinked, "isLinked(self) -> bool");

extern "C" {static PyObject *meth_QGLShaderProgram_isLinked(PyObject *, PyObject *);}
static PyObject *meth_QGLShaderProgram_isLinked(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLShaderProgram, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isLinked();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShaderProgram, sipName_isLinked, doc_QGLShaderProgram_isLinked);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShaderProgram_log, "log(self) -> str");

extern "C" {static PyObject *meth_QGLShaderProgram_log(PyObject *, PyObject *);}
static PyObject *meth_QGLShaderProgram_log(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLShaderProgram, &sipCpp))
        {
             ::QString*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QString(sipCpp->log());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShaderProgram, sipName_log, doc_QGLShaderProgram_log);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShaderProgram_bind, "bind(self) -> bool");

extern "C" {static PyObject *meth_QGLShaderProgram_bind(PyObject *, PyObject *);}
static PyObject *meth_QGLShaderProgram_bind(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLShaderProgram, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->bind();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShaderProgram, sipName_bind, doc_QGLShaderProgram_bind);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShaderProgram_release, "release(self)");

extern "C" {static PyObject *meth_QGLShaderProgram_release(PyObject *, PyObject *);}
static PyObject *meth_QGLShaderProgram_release(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLShaderProgram, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->release();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShaderProgram, sipName_release, doc_QGLShaderProgram_release);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShaderProgram_programId, "programId(self) -> int");

extern "C" {static PyObject *meth_QGLShaderProgram_programId(PyObject *, PyObject *);}
static PyObject *meth_QGLShaderProgram_programId(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLShaderProgram, &sipCpp))
        {
             ::GLuint sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->programId();
            Py_END_ALLOW_THREADS

            return PyLong_FromUnsignedLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShaderProgram, sipName_programId, doc_QGLShaderProgram_programId);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShaderProgram_bindAttributeLocation, "bindAttributeLocation(self, Union[QByteArray, bytes, bytearray], int)\n"
"bindAttributeLocation(self, str, int)");

extern "C" {static PyObject *meth_QGLShaderProgram_bindAttributeLocation(PyObject *, PyObject *);}
static PyObject *meth_QGLShaderProgram_bindAttributeLocation(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QByteArray* a0;
        int a0State = 0;
        int a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1i", &sipSelf, sipType_QGLShaderProgram, &sipCpp, sipType_QByteArray, &a0, &a0State, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->bindAttributeLocation(*a0,a1);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::QByteArray *>(a0),sipType_QByteArray,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const  ::QString* a0;
        int a0State = 0;
        int a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1i", &sipSelf, sipType_QGLShaderProgram, &sipCpp, sipType_QString,&a0, &a0State, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->bindAttributeLocation(*a0,a1);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShaderProgram, sipName_bindAttributeLocation, doc_QGLShaderProgram_bindAttributeLocation);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShaderProgram_attributeLocation, "attributeLocation(self, Union[QByteArray, bytes, bytearray]) -> int\n"
"attributeLocation(self, str) -> int");

extern "C" {static PyObject *meth_QGLShaderProgram_attributeLocation(PyObject *, PyObject *);}
static PyObject *meth_QGLShaderProgram_attributeLocation(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QByteArray* a0;
        int a0State = 0;
        const  ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QGLShaderProgram, &sipCpp, sipType_QByteArray, &a0, &a0State))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->attributeLocation(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::QByteArray *>(a0),sipType_QByteArray,a0State);

            return SIPLong_FromLong(sipRes);
        }
    }

    {
        const  ::QString* a0;
        int a0State = 0;
        const  ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QGLShaderProgram, &sipCpp, sipType_QString,&a0, &a0State))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->attributeLocation(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShaderProgram, sipName_attributeLocation, doc_QGLShaderProgram_attributeLocation);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShaderProgram_setAttributeArray, "setAttributeArray(self, int, PYQT_SHADER_ATTRIBUTE_ARRAY)\n"
"setAttributeArray(self, str, PYQT_SHADER_ATTRIBUTE_ARRAY)");

extern "C" {static PyObject *meth_QGLShaderProgram_setAttributeArray(PyObject *, PyObject *);}
static PyObject *meth_QGLShaderProgram_setAttributeArray(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        PyObject * a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiP0", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0, &a1))
        {
            sipErrorState sipError = sipErrorNone;

#line 101 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qglshaderprogram.sip"
        const GLfloat *values;
        int tsize;
        
        values = qpyopengl_attribute_array(a1, sipSelf, SIPLong_FromLong(a0), &tsize,
                &sipError);
        
        if (values)
            sipCpp->setAttributeArray(a0, values, tsize);
#line 2766 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    {
        const char* a0;
        PyObject *a0Keep;
        PyObject * a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BAAP0", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0Keep, &a0, &a1))
        {
            sipErrorState sipError = sipErrorNone;

#line 113 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qglshaderprogram.sip"
        const GLfloat *values;
        int tsize;
        
        values = qpyopengl_attribute_array(a1, sipSelf, SIPBytes_FromString(a0),
                &tsize, &sipError);
        
        if (values)
            sipCpp->setAttributeArray(a0, values, tsize);
#line 2800 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
            Py_DECREF(a0Keep);

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShaderProgram, sipName_setAttributeArray, doc_QGLShaderProgram_setAttributeArray);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShaderProgram_setAttributeValue, "setAttributeValue(self, int, float)\n"
"setAttributeValue(self, int, float, float)\n"
"setAttributeValue(self, int, float, float, float)\n"
"setAttributeValue(self, int, float, float, float, float)\n"
"setAttributeValue(self, int, QVector2D)\n"
"setAttributeValue(self, int, QVector3D)\n"
"setAttributeValue(self, int, QVector4D)\n"
"setAttributeValue(self, int, Union[QColor, Qt.GlobalColor])\n"
"setAttributeValue(self, str, float)\n"
"setAttributeValue(self, str, float, float)\n"
"setAttributeValue(self, str, float, float, float)\n"
"setAttributeValue(self, str, float, float, float, float)\n"
"setAttributeValue(self, str, QVector2D)\n"
"setAttributeValue(self, str, QVector3D)\n"
"setAttributeValue(self, str, QVector4D)\n"
"setAttributeValue(self, str, Union[QColor, Qt.GlobalColor])");

extern "C" {static PyObject *meth_QGLShaderProgram_setAttributeValue(PyObject *, PyObject *);}
static PyObject *meth_QGLShaderProgram_setAttributeValue(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
         ::GLfloat a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bif", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setAttributeValue(a0,a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
         ::GLfloat a1;
         ::GLfloat a2;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Biff", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0, &a1, &a2))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setAttributeValue(a0,a1,a2);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
         ::GLfloat a1;
         ::GLfloat a2;
         ::GLfloat a3;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bifff", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0, &a1, &a2, &a3))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setAttributeValue(a0,a1,a2,a3);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
         ::GLfloat a1;
         ::GLfloat a2;
         ::GLfloat a3;
         ::GLfloat a4;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Biffff", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0, &a1, &a2, &a3, &a4))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setAttributeValue(a0,a1,a2,a3,a4);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
        const  ::QVector2D* a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiJ9", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0, sipType_QVector2D, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setAttributeValue(a0,*a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
        const  ::QVector3D* a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiJ9", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0, sipType_QVector3D, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setAttributeValue(a0,*a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
        const  ::QVector4D* a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiJ9", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0, sipType_QVector4D, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setAttributeValue(a0,*a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
        const  ::QColor* a1;
        int a1State = 0;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiJ1", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0, sipType_QColor, &a1, &a1State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setAttributeValue(a0,*a1);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::QColor *>(a1),sipType_QColor,a1State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        PyObject *a0Keep;
         ::GLfloat a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BAAf", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0Keep, &a0, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setAttributeValue(a0,a1);
            Py_END_ALLOW_THREADS
            Py_DECREF(a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        PyObject *a0Keep;
         ::GLfloat a1;
         ::GLfloat a2;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BAAff", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0Keep, &a0, &a1, &a2))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setAttributeValue(a0,a1,a2);
            Py_END_ALLOW_THREADS
            Py_DECREF(a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        PyObject *a0Keep;
         ::GLfloat a1;
         ::GLfloat a2;
         ::GLfloat a3;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BAAfff", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0Keep, &a0, &a1, &a2, &a3))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setAttributeValue(a0,a1,a2,a3);
            Py_END_ALLOW_THREADS
            Py_DECREF(a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        PyObject *a0Keep;
         ::GLfloat a1;
         ::GLfloat a2;
         ::GLfloat a3;
         ::GLfloat a4;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BAAffff", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0Keep, &a0, &a1, &a2, &a3, &a4))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setAttributeValue(a0,a1,a2,a3,a4);
            Py_END_ALLOW_THREADS
            Py_DECREF(a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        PyObject *a0Keep;
        const  ::QVector2D* a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BAAJ9", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0Keep, &a0, sipType_QVector2D, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setAttributeValue(a0,*a1);
            Py_END_ALLOW_THREADS
            Py_DECREF(a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        PyObject *a0Keep;
        const  ::QVector3D* a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BAAJ9", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0Keep, &a0, sipType_QVector3D, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setAttributeValue(a0,*a1);
            Py_END_ALLOW_THREADS
            Py_DECREF(a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        PyObject *a0Keep;
        const  ::QVector4D* a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BAAJ9", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0Keep, &a0, sipType_QVector4D, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setAttributeValue(a0,*a1);
            Py_END_ALLOW_THREADS
            Py_DECREF(a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        PyObject *a0Keep;
        const  ::QColor* a1;
        int a1State = 0;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BAAJ1", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0Keep, &a0, sipType_QColor, &a1, &a1State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setAttributeValue(a0,*a1);
            Py_END_ALLOW_THREADS
            Py_DECREF(a0Keep);
            sipReleaseType(const_cast< ::QColor *>(a1),sipType_QColor,a1State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShaderProgram, sipName_setAttributeValue, doc_QGLShaderProgram_setAttributeValue);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShaderProgram_enableAttributeArray, "enableAttributeArray(self, int)\n"
"enableAttributeArray(self, str)");

extern "C" {static PyObject *meth_QGLShaderProgram_enableAttributeArray(PyObject *, PyObject *);}
static PyObject *meth_QGLShaderProgram_enableAttributeArray(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->enableAttributeArray(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        PyObject *a0Keep;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BAA", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0Keep, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->enableAttributeArray(a0);
            Py_END_ALLOW_THREADS
            Py_DECREF(a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShaderProgram, sipName_enableAttributeArray, doc_QGLShaderProgram_enableAttributeArray);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShaderProgram_disableAttributeArray, "disableAttributeArray(self, int)\n"
"disableAttributeArray(self, str)");

extern "C" {static PyObject *meth_QGLShaderProgram_disableAttributeArray(PyObject *, PyObject *);}
static PyObject *meth_QGLShaderProgram_disableAttributeArray(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->disableAttributeArray(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        PyObject *a0Keep;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BAA", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0Keep, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->disableAttributeArray(a0);
            Py_END_ALLOW_THREADS
            Py_DECREF(a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShaderProgram, sipName_disableAttributeArray, doc_QGLShaderProgram_disableAttributeArray);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShaderProgram_uniformLocation, "uniformLocation(self, Union[QByteArray, bytes, bytearray]) -> int\n"
"uniformLocation(self, str) -> int");

extern "C" {static PyObject *meth_QGLShaderProgram_uniformLocation(PyObject *, PyObject *);}
static PyObject *meth_QGLShaderProgram_uniformLocation(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QByteArray* a0;
        int a0State = 0;
        const  ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QGLShaderProgram, &sipCpp, sipType_QByteArray, &a0, &a0State))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->uniformLocation(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::QByteArray *>(a0),sipType_QByteArray,a0State);

            return SIPLong_FromLong(sipRes);
        }
    }

    {
        const  ::QString* a0;
        int a0State = 0;
        const  ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QGLShaderProgram, &sipCpp, sipType_QString,&a0, &a0State))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->uniformLocation(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShaderProgram, sipName_uniformLocation, doc_QGLShaderProgram_uniformLocation);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShaderProgram_setUniformValueArray, "setUniformValueArray(self, int, PYQT_SHADER_UNIFORM_VALUE_ARRAY)\n"
"setUniformValueArray(self, str, PYQT_SHADER_UNIFORM_VALUE_ARRAY)");

extern "C" {static PyObject *meth_QGLShaderProgram_setUniformValueArray(PyObject *, PyObject *);}
static PyObject *meth_QGLShaderProgram_setUniformValueArray(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        PyObject * a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiP0", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0, &a1))
        {
            sipErrorState sipError = sipErrorNone;

#line 147 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qglshaderprogram.sip"
        const void *values;
        const sipTypeDef *array_type;
        int array_len, tsize;
        
        values = qpyopengl_uniform_value_array(a1, sipSelf, SIPLong_FromLong(a0),
                    &array_type, &array_len, &tsize, &sipError);
                
        if (values)
        {
            if (array_type == sipType_QVector2D)
                sipCpp->setUniformValueArray(a0,
                        reinterpret_cast<const QVector2D *>(values), array_len);
            else if (array_type == sipType_QVector3D)
                sipCpp->setUniformValueArray(a0,
                        reinterpret_cast<const QVector3D *>(values), array_len);
            else if (array_type == sipType_QVector4D)
                sipCpp->setUniformValueArray(a0,
                        reinterpret_cast<const QVector4D *>(values), array_len);
            else if (array_type == sipType_QMatrix2x2)
                sipCpp->setUniformValueArray(a0,
                        reinterpret_cast<const QMatrix2x2 *>(values), array_len);
            else if (array_type == sipType_QMatrix2x3)
                sipCpp->setUniformValueArray(a0,
                        reinterpret_cast<const QMatrix2x3 *>(values), array_len);
            else if (array_type == sipType_QMatrix2x4)
                sipCpp->setUniformValueArray(a0,
                        reinterpret_cast<const QMatrix2x4 *>(values), array_len);
            else if (array_type == sipType_QMatrix3x2)
                sipCpp->setUniformValueArray(a0,
                        reinterpret_cast<const QMatrix3x2 *>(values), array_len);
            else if (array_type == sipType_QMatrix3x3)
                sipCpp->setUniformValueArray(a0,
                        reinterpret_cast<const QMatrix3x3 *>(values), array_len);
            else if (array_type == sipType_QMatrix3x4)
                sipCpp->setUniformValueArray(a0,
                        reinterpret_cast<const QMatrix3x4 *>(values), array_len);
            else if (array_type == sipType_QMatrix4x2)
                sipCpp->setUniformValueArray(a0,
                        reinterpret_cast<const QMatrix4x2 *>(values), array_len);
            else if (array_type == sipType_QMatrix4x3)
                sipCpp->setUniformValueArray(a0,
                        reinterpret_cast<const QMatrix4x3 *>(values), array_len);
            else if (array_type == sipType_QMatrix4x4)
                sipCpp->setUniformValueArray(a0,
                        reinterpret_cast<const QMatrix4x4 *>(values), array_len);
            else
                sipCpp->setUniformValueArray(a0,
                        reinterpret_cast<const GLfloat *>(values), array_len, tsize);
        }
#line 3376 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    {
        const char* a0;
        PyObject *a0Keep;
        PyObject * a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BAAP0", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0Keep, &a0, &a1))
        {
            sipErrorState sipError = sipErrorNone;

#line 200 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qglshaderprogram.sip"
        const void *values;
        const sipTypeDef *array_type;
        int array_len, tsize;
        
        values = qpyopengl_uniform_value_array(a1, sipSelf, SIPBytes_FromString(a0),
                    &array_type, &array_len, &tsize, &sipError);
                
        if (values)
        {
            if (array_type == sipType_QVector2D)
                sipCpp->setUniformValueArray(a0,
                        reinterpret_cast<const QVector2D *>(values), array_len);
            else if (array_type == sipType_QVector3D)
                sipCpp->setUniformValueArray(a0,
                        reinterpret_cast<const QVector3D *>(values), array_len);
            else if (array_type == sipType_QVector4D)
                sipCpp->setUniformValueArray(a0,
                        reinterpret_cast<const QVector4D *>(values), array_len);
            else if (array_type == sipType_QMatrix2x2)
                sipCpp->setUniformValueArray(a0,
                        reinterpret_cast<const QMatrix2x2 *>(values), array_len);
            else if (array_type == sipType_QMatrix2x3)
                sipCpp->setUniformValueArray(a0,
                        reinterpret_cast<const QMatrix2x3 *>(values), array_len);
            else if (array_type == sipType_QMatrix2x4)
                sipCpp->setUniformValueArray(a0,
                        reinterpret_cast<const QMatrix2x4 *>(values), array_len);
            else if (array_type == sipType_QMatrix3x2)
                sipCpp->setUniformValueArray(a0,
                        reinterpret_cast<const QMatrix3x2 *>(values), array_len);
            else if (array_type == sipType_QMatrix3x3)
                sipCpp->setUniformValueArray(a0,
                        reinterpret_cast<const QMatrix3x3 *>(values), array_len);
            else if (array_type == sipType_QMatrix3x4)
                sipCpp->setUniformValueArray(a0,
                        reinterpret_cast<const QMatrix3x4 *>(values), array_len);
            else if (array_type == sipType_QMatrix4x2)
                sipCpp->setUniformValueArray(a0,
                        reinterpret_cast<const QMatrix4x2 *>(values), array_len);
            else if (array_type == sipType_QMatrix4x3)
                sipCpp->setUniformValueArray(a0,
                        reinterpret_cast<const QMatrix4x3 *>(values), array_len);
            else if (array_type == sipType_QMatrix4x4)
                sipCpp->setUniformValueArray(a0,
                        reinterpret_cast<const QMatrix4x4 *>(values), array_len);
            else
                sipCpp->setUniformValueArray(a0,
                        reinterpret_cast<const GLfloat *>(values), array_len, tsize);
        }
#line 3451 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
            Py_DECREF(a0Keep);

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShaderProgram, sipName_setUniformValueArray, doc_QGLShaderProgram_setUniformValueArray);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShaderProgram_setUniformValue, "setUniformValue(self, int, int)\n"
"setUniformValue(self, int, float)\n"
"setUniformValue(self, int, float, float)\n"
"setUniformValue(self, int, float, float, float)\n"
"setUniformValue(self, int, float, float, float, float)\n"
"setUniformValue(self, int, QVector2D)\n"
"setUniformValue(self, int, QVector3D)\n"
"setUniformValue(self, int, QVector4D)\n"
"setUniformValue(self, int, Union[QColor, Qt.GlobalColor])\n"
"setUniformValue(self, int, QPoint)\n"
"setUniformValue(self, int, Union[QPointF, QPoint])\n"
"setUniformValue(self, int, QSize)\n"
"setUniformValue(self, int, QSizeF)\n"
"setUniformValue(self, int, QMatrix2x2)\n"
"setUniformValue(self, int, QMatrix2x3)\n"
"setUniformValue(self, int, QMatrix2x4)\n"
"setUniformValue(self, int, QMatrix3x2)\n"
"setUniformValue(self, int, QMatrix3x3)\n"
"setUniformValue(self, int, QMatrix3x4)\n"
"setUniformValue(self, int, QMatrix4x2)\n"
"setUniformValue(self, int, QMatrix4x3)\n"
"setUniformValue(self, int, QMatrix4x4)\n"
"setUniformValue(self, int, QTransform)\n"
"setUniformValue(self, str, int)\n"
"setUniformValue(self, str, float)\n"
"setUniformValue(self, str, float, float)\n"
"setUniformValue(self, str, float, float, float)\n"
"setUniformValue(self, str, float, float, float, float)\n"
"setUniformValue(self, str, QVector2D)\n"
"setUniformValue(self, str, QVector3D)\n"
"setUniformValue(self, str, QVector4D)\n"
"setUniformValue(self, str, Union[QColor, Qt.GlobalColor])\n"
"setUniformValue(self, str, QPoint)\n"
"setUniformValue(self, str, Union[QPointF, QPoint])\n"
"setUniformValue(self, str, QSize)\n"
"setUniformValue(self, str, QSizeF)\n"
"setUniformValue(self, str, QMatrix2x2)\n"
"setUniformValue(self, str, QMatrix2x3)\n"
"setUniformValue(self, str, QMatrix2x4)\n"
"setUniformValue(self, str, QMatrix3x2)\n"
"setUniformValue(self, str, QMatrix3x3)\n"
"setUniformValue(self, str, QMatrix3x4)\n"
"setUniformValue(self, str, QMatrix4x2)\n"
"setUniformValue(self, str, QMatrix4x3)\n"
"setUniformValue(self, str, QMatrix4x4)\n"
"setUniformValue(self, str, QTransform)");

extern "C" {static PyObject *meth_QGLShaderProgram_setUniformValue(PyObject *, PyObject *);}
static PyObject *meth_QGLShaderProgram_setUniformValue(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
         ::GLint a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiXi", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
         ::GLfloat a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiXf", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
         ::GLfloat a1;
         ::GLfloat a2;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Biff", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0, &a1, &a2))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,a1,a2);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
         ::GLfloat a1;
         ::GLfloat a2;
         ::GLfloat a3;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bifff", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0, &a1, &a2, &a3))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,a1,a2,a3);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
         ::GLfloat a1;
         ::GLfloat a2;
         ::GLfloat a3;
         ::GLfloat a4;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Biffff", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0, &a1, &a2, &a3, &a4))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,a1,a2,a3,a4);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
        const  ::QVector2D* a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiJ9", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0, sipType_QVector2D, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,*a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
        const  ::QVector3D* a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiJ9", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0, sipType_QVector3D, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,*a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
        const  ::QVector4D* a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiJ9", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0, sipType_QVector4D, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,*a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
        const  ::QColor* a1;
        int a1State = 0;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiJ1", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0, sipType_QColor, &a1, &a1State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,*a1);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::QColor *>(a1),sipType_QColor,a1State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
        const  ::QPoint* a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiJ9", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0, sipType_QPoint, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,*a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
        const  ::QPointF* a1;
        int a1State = 0;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiJ1", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0, sipType_QPointF, &a1, &a1State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,*a1);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::QPointF *>(a1),sipType_QPointF,a1State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
        const  ::QSize* a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiJ9", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0, sipType_QSize, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,*a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
        const  ::QSizeF* a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiJ9", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0, sipType_QSizeF, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,*a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
        const  ::QMatrix2x2* a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiJ9", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0, sipType_QMatrix2x2, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,*a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
        const  ::QMatrix2x3* a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiJ9", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0, sipType_QMatrix2x3, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,*a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
        const  ::QMatrix2x4* a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiJ9", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0, sipType_QMatrix2x4, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,*a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
        const  ::QMatrix3x2* a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiJ9", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0, sipType_QMatrix3x2, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,*a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
        const  ::QMatrix3x3* a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiJ9", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0, sipType_QMatrix3x3, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,*a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
        const  ::QMatrix3x4* a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiJ9", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0, sipType_QMatrix3x4, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,*a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
        const  ::QMatrix4x2* a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiJ9", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0, sipType_QMatrix4x2, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,*a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
        const  ::QMatrix4x3* a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiJ9", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0, sipType_QMatrix4x3, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,*a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
        const  ::QMatrix4x4* a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiJ9", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0, sipType_QMatrix4x4, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,*a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
        const  ::QTransform* a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiJ9", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0, sipType_QTransform, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,*a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        PyObject *a0Keep;
         ::GLint a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BAAXi", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0Keep, &a0, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,a1);
            Py_END_ALLOW_THREADS
            Py_DECREF(a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        PyObject *a0Keep;
         ::GLfloat a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BAAXf", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0Keep, &a0, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,a1);
            Py_END_ALLOW_THREADS
            Py_DECREF(a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        PyObject *a0Keep;
         ::GLfloat a1;
         ::GLfloat a2;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BAAff", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0Keep, &a0, &a1, &a2))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,a1,a2);
            Py_END_ALLOW_THREADS
            Py_DECREF(a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        PyObject *a0Keep;
         ::GLfloat a1;
         ::GLfloat a2;
         ::GLfloat a3;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BAAfff", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0Keep, &a0, &a1, &a2, &a3))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,a1,a2,a3);
            Py_END_ALLOW_THREADS
            Py_DECREF(a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        PyObject *a0Keep;
         ::GLfloat a1;
         ::GLfloat a2;
         ::GLfloat a3;
         ::GLfloat a4;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BAAffff", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0Keep, &a0, &a1, &a2, &a3, &a4))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,a1,a2,a3,a4);
            Py_END_ALLOW_THREADS
            Py_DECREF(a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        PyObject *a0Keep;
        const  ::QVector2D* a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BAAJ9", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0Keep, &a0, sipType_QVector2D, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,*a1);
            Py_END_ALLOW_THREADS
            Py_DECREF(a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        PyObject *a0Keep;
        const  ::QVector3D* a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BAAJ9", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0Keep, &a0, sipType_QVector3D, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,*a1);
            Py_END_ALLOW_THREADS
            Py_DECREF(a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        PyObject *a0Keep;
        const  ::QVector4D* a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BAAJ9", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0Keep, &a0, sipType_QVector4D, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,*a1);
            Py_END_ALLOW_THREADS
            Py_DECREF(a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        PyObject *a0Keep;
        const  ::QColor* a1;
        int a1State = 0;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BAAJ1", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0Keep, &a0, sipType_QColor, &a1, &a1State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,*a1);
            Py_END_ALLOW_THREADS
            Py_DECREF(a0Keep);
            sipReleaseType(const_cast< ::QColor *>(a1),sipType_QColor,a1State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        PyObject *a0Keep;
        const  ::QPoint* a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BAAJ9", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0Keep, &a0, sipType_QPoint, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,*a1);
            Py_END_ALLOW_THREADS
            Py_DECREF(a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        PyObject *a0Keep;
        const  ::QPointF* a1;
        int a1State = 0;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BAAJ1", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0Keep, &a0, sipType_QPointF, &a1, &a1State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,*a1);
            Py_END_ALLOW_THREADS
            Py_DECREF(a0Keep);
            sipReleaseType(const_cast< ::QPointF *>(a1),sipType_QPointF,a1State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        PyObject *a0Keep;
        const  ::QSize* a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BAAJ9", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0Keep, &a0, sipType_QSize, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,*a1);
            Py_END_ALLOW_THREADS
            Py_DECREF(a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        PyObject *a0Keep;
        const  ::QSizeF* a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BAAJ9", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0Keep, &a0, sipType_QSizeF, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,*a1);
            Py_END_ALLOW_THREADS
            Py_DECREF(a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        PyObject *a0Keep;
        const  ::QMatrix2x2* a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BAAJ9", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0Keep, &a0, sipType_QMatrix2x2, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,*a1);
            Py_END_ALLOW_THREADS
            Py_DECREF(a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        PyObject *a0Keep;
        const  ::QMatrix2x3* a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BAAJ9", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0Keep, &a0, sipType_QMatrix2x3, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,*a1);
            Py_END_ALLOW_THREADS
            Py_DECREF(a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        PyObject *a0Keep;
        const  ::QMatrix2x4* a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BAAJ9", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0Keep, &a0, sipType_QMatrix2x4, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,*a1);
            Py_END_ALLOW_THREADS
            Py_DECREF(a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        PyObject *a0Keep;
        const  ::QMatrix3x2* a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BAAJ9", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0Keep, &a0, sipType_QMatrix3x2, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,*a1);
            Py_END_ALLOW_THREADS
            Py_DECREF(a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        PyObject *a0Keep;
        const  ::QMatrix3x3* a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BAAJ9", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0Keep, &a0, sipType_QMatrix3x3, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,*a1);
            Py_END_ALLOW_THREADS
            Py_DECREF(a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        PyObject *a0Keep;
        const  ::QMatrix3x4* a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BAAJ9", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0Keep, &a0, sipType_QMatrix3x4, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,*a1);
            Py_END_ALLOW_THREADS
            Py_DECREF(a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        PyObject *a0Keep;
        const  ::QMatrix4x2* a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BAAJ9", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0Keep, &a0, sipType_QMatrix4x2, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,*a1);
            Py_END_ALLOW_THREADS
            Py_DECREF(a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        PyObject *a0Keep;
        const  ::QMatrix4x3* a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BAAJ9", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0Keep, &a0, sipType_QMatrix4x3, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,*a1);
            Py_END_ALLOW_THREADS
            Py_DECREF(a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        PyObject *a0Keep;
        const  ::QMatrix4x4* a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BAAJ9", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0Keep, &a0, sipType_QMatrix4x4, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,*a1);
            Py_END_ALLOW_THREADS
            Py_DECREF(a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        PyObject *a0Keep;
        const  ::QTransform* a1;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BAAJ9", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0Keep, &a0, sipType_QTransform, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUniformValue(a0,*a1);
            Py_END_ALLOW_THREADS
            Py_DECREF(a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShaderProgram, sipName_setUniformValue, doc_QGLShaderProgram_setUniformValue);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShaderProgram_hasOpenGLShaderPrograms, "hasOpenGLShaderPrograms(context: QGLContext = None) -> bool");

extern "C" {static PyObject *meth_QGLShaderProgram_hasOpenGLShaderPrograms(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLShaderProgram_hasOpenGLShaderPrograms(PyObject *, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLContext* a0 = 0;

        static const char *sipKwdList[] = {
            sipName_context,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "|J8", sipType_QGLContext, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes =  ::QGLShaderProgram::hasOpenGLShaderPrograms(a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShaderProgram, sipName_hasOpenGLShaderPrograms, doc_QGLShaderProgram_hasOpenGLShaderPrograms);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShaderProgram_setGeometryOutputVertexCount, "setGeometryOutputVertexCount(self, int)");

extern "C" {static PyObject *meth_QGLShaderProgram_setGeometryOutputVertexCount(PyObject *, PyObject *);}
static PyObject *meth_QGLShaderProgram_setGeometryOutputVertexCount(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setGeometryOutputVertexCount(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShaderProgram, sipName_setGeometryOutputVertexCount, doc_QGLShaderProgram_setGeometryOutputVertexCount);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShaderProgram_geometryOutputVertexCount, "geometryOutputVertexCount(self) -> int");

extern "C" {static PyObject *meth_QGLShaderProgram_geometryOutputVertexCount(PyObject *, PyObject *);}
static PyObject *meth_QGLShaderProgram_geometryOutputVertexCount(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLShaderProgram, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->geometryOutputVertexCount();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShaderProgram, sipName_geometryOutputVertexCount, doc_QGLShaderProgram_geometryOutputVertexCount);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShaderProgram_setGeometryInputType, "setGeometryInputType(self, int)");

extern "C" {static PyObject *meth_QGLShaderProgram_setGeometryInputType(PyObject *, PyObject *);}
static PyObject *meth_QGLShaderProgram_setGeometryInputType(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::GLenum a0;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setGeometryInputType(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShaderProgram, sipName_setGeometryInputType, doc_QGLShaderProgram_setGeometryInputType);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShaderProgram_geometryInputType, "geometryInputType(self) -> int");

extern "C" {static PyObject *meth_QGLShaderProgram_geometryInputType(PyObject *, PyObject *);}
static PyObject *meth_QGLShaderProgram_geometryInputType(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLShaderProgram, &sipCpp))
        {
             ::GLenum sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->geometryInputType();
            Py_END_ALLOW_THREADS

            return PyLong_FromUnsignedLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShaderProgram, sipName_geometryInputType, doc_QGLShaderProgram_geometryInputType);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShaderProgram_setGeometryOutputType, "setGeometryOutputType(self, int)");

extern "C" {static PyObject *meth_QGLShaderProgram_setGeometryOutputType(PyObject *, PyObject *);}
static PyObject *meth_QGLShaderProgram_setGeometryOutputType(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::GLenum a0;
         ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setGeometryOutputType(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShaderProgram, sipName_setGeometryOutputType, doc_QGLShaderProgram_setGeometryOutputType);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShaderProgram_geometryOutputType, "geometryOutputType(self) -> int");

extern "C" {static PyObject *meth_QGLShaderProgram_geometryOutputType(PyObject *, PyObject *);}
static PyObject *meth_QGLShaderProgram_geometryOutputType(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLShaderProgram *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLShaderProgram, &sipCpp))
        {
             ::GLenum sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->geometryOutputType();
            Py_END_ALLOW_THREADS

            return PyLong_FromUnsignedLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShaderProgram, sipName_geometryOutputType, doc_QGLShaderProgram_geometryOutputType);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShaderProgram_setAttributeBuffer, "setAttributeBuffer(self, int, int, int, int, stride: int = 0)\n"
"setAttributeBuffer(self, str, int, int, int, stride: int = 0)");

extern "C" {static PyObject *meth_QGLShaderProgram_setAttributeBuffer(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLShaderProgram_setAttributeBuffer(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
         ::GLenum a1;
        int a2;
        int a3;
        int a4 = 0;
         ::QGLShaderProgram *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            NULL,
            NULL,
            sipName_stride,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "Biuii|i", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0, &a1, &a2, &a3, &a4))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setAttributeBuffer(a0,a1,a2,a3,a4);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const char* a0;
        PyObject *a0Keep;
         ::GLenum a1;
        int a2;
        int a3;
        int a4 = 0;
         ::QGLShaderProgram *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            NULL,
            NULL,
            sipName_stride,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BAAuii|i", &sipSelf, sipType_QGLShaderProgram, &sipCpp, &a0Keep, &a0, &a1, &a2, &a3, &a4))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setAttributeBuffer(a0,a1,a2,a3,a4);
            Py_END_ALLOW_THREADS
            Py_DECREF(a0Keep);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShaderProgram, sipName_setAttributeBuffer, doc_QGLShaderProgram_setAttributeBuffer);

    return NULL;
}


/* Cast a pointer to a type somewhere in its inheritance hierarchy. */
extern "C" {static void *cast_QGLShaderProgram(void *, const sipTypeDef *);}
static void *cast_QGLShaderProgram(void *sipCppV, const sipTypeDef *targetType)
{
     ::QGLShaderProgram *sipCpp = reinterpret_cast< ::QGLShaderProgram *>(sipCppV);

    if (targetType == sipType_QObject)
        return static_cast< ::QObject *>(sipCpp);

    return sipCppV;
}


/* Call the instance's destructor. */
extern "C" {static void release_QGLShaderProgram(void *, int);}
static void release_QGLShaderProgram(void *sipCppV, int)
{
     ::QGLShaderProgram *sipCpp = reinterpret_cast< ::QGLShaderProgram *>(sipCppV);

    Py_BEGIN_ALLOW_THREADS

    if (QThread::currentThread() == sipCpp->thread())
        delete sipCpp;
    else
        sipCpp->deleteLater();

    Py_END_ALLOW_THREADS
}


extern "C" {static void dealloc_QGLShaderProgram(sipSimpleWrapper *);}
static void dealloc_QGLShaderProgram(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerivedClass(sipSelf))
        reinterpret_cast<sipQGLShaderProgram *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsOwnedByPython(sipSelf))
    {
        release_QGLShaderProgram(sipGetAddress(sipSelf), sipIsDerivedClass(sipSelf));
    }
}


extern "C" {static void *init_type_QGLShaderProgram(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QGLShaderProgram(sipSimpleWrapper *sipSelf, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **sipOwner, PyObject **sipParseErr)
{
    sipQGLShaderProgram *sipCpp = 0;

    {
         ::QObject* a0 = 0;

        static const char *sipKwdList[] = {
            sipName_parent,
        };

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "|JH", sipType_QObject, &a0, sipOwner))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQGLShaderProgram(a0);
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    {
        const  ::QGLContext* a0;
         ::QObject* a1 = 0;

        static const char *sipKwdList[] = {
            NULL,
            sipName_parent,
        };

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "J8|JH", sipType_QGLContext, &a0, sipType_QObject, &a1, sipOwner))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQGLShaderProgram(a0,a1);
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's super-types. */
static sipEncodedTypeDef supers_QGLShaderProgram[] = {{3, 0, 1}};


static PyMethodDef methods_QGLShaderProgram[] = {
    {SIP_MLNAME_CAST(sipName_addShader), meth_QGLShaderProgram_addShader, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLShaderProgram_addShader)},
    {SIP_MLNAME_CAST(sipName_addShaderFromSourceCode), meth_QGLShaderProgram_addShaderFromSourceCode, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLShaderProgram_addShaderFromSourceCode)},
    {SIP_MLNAME_CAST(sipName_addShaderFromSourceFile), meth_QGLShaderProgram_addShaderFromSourceFile, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLShaderProgram_addShaderFromSourceFile)},
    {SIP_MLNAME_CAST(sipName_attributeLocation), meth_QGLShaderProgram_attributeLocation, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLShaderProgram_attributeLocation)},
    {SIP_MLNAME_CAST(sipName_bind), meth_QGLShaderProgram_bind, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLShaderProgram_bind)},
    {SIP_MLNAME_CAST(sipName_bindAttributeLocation), meth_QGLShaderProgram_bindAttributeLocation, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLShaderProgram_bindAttributeLocation)},
    {SIP_MLNAME_CAST(sipName_childEvent), (PyCFunction)meth_QGLShaderProgram_childEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_connectNotify), (PyCFunction)meth_QGLShaderProgram_connectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_customEvent), (PyCFunction)meth_QGLShaderProgram_customEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_disableAttributeArray), meth_QGLShaderProgram_disableAttributeArray, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLShaderProgram_disableAttributeArray)},
    {SIP_MLNAME_CAST(sipName_disconnectNotify), (PyCFunction)meth_QGLShaderProgram_disconnectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_enableAttributeArray), meth_QGLShaderProgram_enableAttributeArray, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLShaderProgram_enableAttributeArray)},
    {SIP_MLNAME_CAST(sipName_geometryInputType), meth_QGLShaderProgram_geometryInputType, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLShaderProgram_geometryInputType)},
    {SIP_MLNAME_CAST(sipName_geometryOutputType), meth_QGLShaderProgram_geometryOutputType, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLShaderProgram_geometryOutputType)},
    {SIP_MLNAME_CAST(sipName_geometryOutputVertexCount), meth_QGLShaderProgram_geometryOutputVertexCount, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLShaderProgram_geometryOutputVertexCount)},
    {SIP_MLNAME_CAST(sipName_hasOpenGLShaderPrograms), (PyCFunction)meth_QGLShaderProgram_hasOpenGLShaderPrograms, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLShaderProgram_hasOpenGLShaderPrograms)},
    {SIP_MLNAME_CAST(sipName_isLinked), meth_QGLShaderProgram_isLinked, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLShaderProgram_isLinked)},
    {SIP_MLNAME_CAST(sipName_link), meth_QGLShaderProgram_link, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLShaderProgram_link)},
    {SIP_MLNAME_CAST(sipName_log), meth_QGLShaderProgram_log, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLShaderProgram_log)},
    {SIP_MLNAME_CAST(sipName_programId), meth_QGLShaderProgram_programId, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLShaderProgram_programId)},
    {SIP_MLNAME_CAST(sipName_receivers), (PyCFunction)meth_QGLShaderProgram_receivers, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_release), meth_QGLShaderProgram_release, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLShaderProgram_release)},
    {SIP_MLNAME_CAST(sipName_removeAllShaders), meth_QGLShaderProgram_removeAllShaders, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLShaderProgram_removeAllShaders)},
    {SIP_MLNAME_CAST(sipName_removeShader), meth_QGLShaderProgram_removeShader, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLShaderProgram_removeShader)},
    {SIP_MLNAME_CAST(sipName_sender), (PyCFunction)meth_QGLShaderProgram_sender, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_senderSignalIndex), (PyCFunction)meth_QGLShaderProgram_senderSignalIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_setAttributeArray), meth_QGLShaderProgram_setAttributeArray, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLShaderProgram_setAttributeArray)},
    {SIP_MLNAME_CAST(sipName_setAttributeBuffer), (PyCFunction)meth_QGLShaderProgram_setAttributeBuffer, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLShaderProgram_setAttributeBuffer)},
    {SIP_MLNAME_CAST(sipName_setAttributeValue), meth_QGLShaderProgram_setAttributeValue, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLShaderProgram_setAttributeValue)},
    {SIP_MLNAME_CAST(sipName_setGeometryInputType), meth_QGLShaderProgram_setGeometryInputType, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLShaderProgram_setGeometryInputType)},
    {SIP_MLNAME_CAST(sipName_setGeometryOutputType), meth_QGLShaderProgram_setGeometryOutputType, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLShaderProgram_setGeometryOutputType)},
    {SIP_MLNAME_CAST(sipName_setGeometryOutputVertexCount), meth_QGLShaderProgram_setGeometryOutputVertexCount, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLShaderProgram_setGeometryOutputVertexCount)},
    {SIP_MLNAME_CAST(sipName_setUniformValue), meth_QGLShaderProgram_setUniformValue, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLShaderProgram_setUniformValue)},
    {SIP_MLNAME_CAST(sipName_setUniformValueArray), meth_QGLShaderProgram_setUniformValueArray, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLShaderProgram_setUniformValueArray)},
    {SIP_MLNAME_CAST(sipName_shaders), meth_QGLShaderProgram_shaders, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLShaderProgram_shaders)},
    {SIP_MLNAME_CAST(sipName_timerEvent), (PyCFunction)meth_QGLShaderProgram_timerEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_uniformLocation), meth_QGLShaderProgram_uniformLocation, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLShaderProgram_uniformLocation)}
};

PyDoc_STRVAR(doc_QGLShaderProgram, "\1QGLShaderProgram(parent: QObject = None)\n"
"QGLShaderProgram(QGLContext, parent: QObject = None)");


static pyqt4ClassPluginDef plugin_QGLShaderProgram = {
    & ::QGLShaderProgram::staticMetaObject,
    0,
    0
};


sipClassTypeDef sipTypeDef_QtOpenGL_QGLShaderProgram = {
    {
        -1,
        0,
        0,
        SIP_TYPE_SCC|SIP_TYPE_CLASS,
        sipNameNr_QGLShaderProgram,
        {0},
        &plugin_QGLShaderProgram
    },
    {
        sipNameNr_QGLShaderProgram,
        {0, 0, 1},
        37, methods_QGLShaderProgram,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QGLShaderProgram,
    -1,
    -1,
    supers_QGLShaderProgram,
    0,
    init_type_QGLShaderProgram,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QGLShaderProgram,
    0,
    0,
    0,
    release_QGLShaderProgram,
    cast_QGLShaderProgram,
    0,
    0,
    0,
    0,
    0,
    0
};

#line 29 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qglshaderprogram.sip"
#include <qglshaderprogram.h>
#line 4868 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

#line 29 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qglshaderprogram.sip"
#include <qglshaderprogram.h>
#line 4872 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"


extern "C" {static int slot_QGLShader_ShaderType___bool__(PyObject *);}
static int slot_QGLShader_ShaderType___bool__(PyObject *sipSelf)
{
     ::QGLShader::ShaderType *sipCpp = reinterpret_cast< ::QGLShader::ShaderType *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGLShader_ShaderType));

    if (!sipCpp)
        return -1;


    {
        {
            int sipRes = 0;

#line 381 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qglobal.sip"
#if QT_VERSION >= 0x050000
        sipRes = (sipCpp->operator QGLShader::ShaderType::Int() != 0);
#else
        sipRes = (sipCpp->operator int() != 0);
#endif
#line 4894 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

            return sipRes;
        }
    }

    return 0;
}


extern "C" {static PyObject *slot_QGLShader_ShaderType___ne__(PyObject *,PyObject *);}
static PyObject *slot_QGLShader_ShaderType___ne__(PyObject *sipSelf,PyObject *sipArg)
{
     ::QGLShader::ShaderType *sipCpp = reinterpret_cast< ::QGLShader::ShaderType *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGLShader_ShaderType));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const  ::QGLShader::ShaderType* a0;
        int a0State = 0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J1", sipType_QGLShader_ShaderType, &a0, &a0State))
        {
            bool sipRes = 0;

#line 372 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qglobal.sip"
#if QT_VERSION >= 0x050000
        sipRes = (sipCpp->operator QGLShader::ShaderType::Int() != a0->operator QGLShader::ShaderType::Int());
#else
        sipRes = (sipCpp->operator int() != a0->operator int());
#endif
#line 4928 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
            sipReleaseType(const_cast< ::QGLShader::ShaderType *>(a0),sipType_QGLShader_ShaderType,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtOpenGL, ne_slot, sipType_QGLShader_ShaderType, sipSelf, sipArg);
}


extern "C" {static PyObject *slot_QGLShader_ShaderType___eq__(PyObject *,PyObject *);}
static PyObject *slot_QGLShader_ShaderType___eq__(PyObject *sipSelf,PyObject *sipArg)
{
     ::QGLShader::ShaderType *sipCpp = reinterpret_cast< ::QGLShader::ShaderType *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGLShader_ShaderType));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const  ::QGLShader::ShaderType* a0;
        int a0State = 0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J1", sipType_QGLShader_ShaderType, &a0, &a0State))
        {
            bool sipRes = 0;

#line 363 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qglobal.sip"
#if QT_VERSION >= 0x050000
        sipRes = (sipCpp->operator QGLShader::ShaderType::Int() == a0->operator QGLShader::ShaderType::Int());
#else
        sipRes = (sipCpp->operator int() == a0->operator int());
#endif
#line 4968 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
            sipReleaseType(const_cast< ::QGLShader::ShaderType *>(a0),sipType_QGLShader_ShaderType,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtOpenGL, eq_slot, sipType_QGLShader_ShaderType, sipSelf, sipArg);
}


extern "C" {static PyObject *slot_QGLShader_ShaderType___ixor__(PyObject *,PyObject *);}
static PyObject *slot_QGLShader_ShaderType___ixor__(PyObject *sipSelf,PyObject *sipArg)
{
    if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QGLShader_ShaderType)))
    {
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    }

     ::QGLShader::ShaderType *sipCpp = reinterpret_cast< ::QGLShader::ShaderType *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGLShader_ShaderType));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        int a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1i", &a0))
        {
#line 357 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qglobal.sip"
        *sipCpp = QGLShader::ShaderType(*sipCpp ^ a0);
#line 5007 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

            Py_INCREF(sipSelf);
            return sipSelf;
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    PyErr_Clear();

    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}


extern "C" {static PyObject *slot_QGLShader_ShaderType___xor__(PyObject *,PyObject *);}
static PyObject *slot_QGLShader_ShaderType___xor__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLShader::ShaderType* a0;
        int a0State = 0;
        int a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J1i", sipType_QGLShader_ShaderType, &a0, &a0State, &a1))
        {
             ::QGLShader::ShaderType*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QGLShader::ShaderType((*a0 ^ a1));
            Py_END_ALLOW_THREADS
            sipReleaseType(a0,sipType_QGLShader_ShaderType,a0State);

            return sipConvertFromNewType(sipRes,sipType_QGLShader_ShaderType,NULL);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtOpenGL, xor_slot, NULL, sipArg0, sipArg1);
}


extern "C" {static PyObject *slot_QGLShader_ShaderType___ior__(PyObject *,PyObject *);}
static PyObject *slot_QGLShader_ShaderType___ior__(PyObject *sipSelf,PyObject *sipArg)
{
    if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QGLShader_ShaderType)))
    {
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    }

     ::QGLShader::ShaderType *sipCpp = reinterpret_cast< ::QGLShader::ShaderType *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGLShader_ShaderType));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        int a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1i", &a0))
        {
#line 351 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qglobal.sip"
        *sipCpp = QGLShader::ShaderType(*sipCpp | a0);
#line 5081 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

            Py_INCREF(sipSelf);
            return sipSelf;
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    PyErr_Clear();

    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}


extern "C" {static PyObject *slot_QGLShader_ShaderType___or__(PyObject *,PyObject *);}
static PyObject *slot_QGLShader_ShaderType___or__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLShader::ShaderType* a0;
        int a0State = 0;
        int a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J1i", sipType_QGLShader_ShaderType, &a0, &a0State, &a1))
        {
             ::QGLShader::ShaderType*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QGLShader::ShaderType((*a0 | a1));
            Py_END_ALLOW_THREADS
            sipReleaseType(a0,sipType_QGLShader_ShaderType,a0State);

            return sipConvertFromNewType(sipRes,sipType_QGLShader_ShaderType,NULL);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtOpenGL, or_slot, NULL, sipArg0, sipArg1);
}


extern "C" {static PyObject *slot_QGLShader_ShaderType___iand__(PyObject *,PyObject *);}
static PyObject *slot_QGLShader_ShaderType___iand__(PyObject *sipSelf,PyObject *sipArg)
{
    if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QGLShader_ShaderType)))
    {
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    }

     ::QGLShader::ShaderType *sipCpp = reinterpret_cast< ::QGLShader::ShaderType *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGLShader_ShaderType));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        int a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1i", &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp-> ::QGLShader::ShaderType::operator&=(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(sipSelf);
            return sipSelf;
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    PyErr_Clear();

    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}


extern "C" {static PyObject *slot_QGLShader_ShaderType___and__(PyObject *,PyObject *);}
static PyObject *slot_QGLShader_ShaderType___and__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLShader::ShaderType* a0;
        int a0State = 0;
        int a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J1i", sipType_QGLShader_ShaderType, &a0, &a0State, &a1))
        {
             ::QGLShader::ShaderType*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QGLShader::ShaderType((*a0 & a1));
            Py_END_ALLOW_THREADS
            sipReleaseType(a0,sipType_QGLShader_ShaderType,a0State);

            return sipConvertFromNewType(sipRes,sipType_QGLShader_ShaderType,NULL);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtOpenGL, and_slot, NULL, sipArg0, sipArg1);
}


extern "C" {static PyObject *slot_QGLShader_ShaderType___invert__(PyObject *);}
static PyObject *slot_QGLShader_ShaderType___invert__(PyObject *sipSelf)
{
     ::QGLShader::ShaderType *sipCpp = reinterpret_cast< ::QGLShader::ShaderType *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGLShader_ShaderType));

    if (!sipCpp)
        return 0;


    {
        {
             ::QGLShader::ShaderType*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QGLShader::ShaderType(~(*sipCpp));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QGLShader_ShaderType,NULL);
        }
    }

    return 0;
}


extern "C" {static PyObject *slot_QGLShader_ShaderType___int__(PyObject *);}
static PyObject *slot_QGLShader_ShaderType___int__(PyObject *sipSelf)
{
     ::QGLShader::ShaderType *sipCpp = reinterpret_cast< ::QGLShader::ShaderType *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGLShader_ShaderType));

    if (!sipCpp)
        return 0;


    {
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = *sipCpp;
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    return 0;
}


/* Call the instance's destructor. */
extern "C" {static void release_QGLShader_ShaderType(void *, int);}
static void release_QGLShader_ShaderType(void *sipCppV, int)
{
    Py_BEGIN_ALLOW_THREADS

    delete reinterpret_cast< ::QGLShader::ShaderType *>(sipCppV);

    Py_END_ALLOW_THREADS
}


extern "C" {static void assign_QGLShader_ShaderType(void *, SIP_SSIZE_T, void *);}
static void assign_QGLShader_ShaderType(void *sipDst, SIP_SSIZE_T sipDstIdx, void *sipSrc)
{
    reinterpret_cast< ::QGLShader::ShaderType *>(sipDst)[sipDstIdx] = *reinterpret_cast< ::QGLShader::ShaderType *>(sipSrc);
}


extern "C" {static void *array_QGLShader_ShaderType(SIP_SSIZE_T);}
static void *array_QGLShader_ShaderType(SIP_SSIZE_T sipNrElem)
{
    return new  ::QGLShader::ShaderType[sipNrElem];
}


extern "C" {static void *copy_QGLShader_ShaderType(const void *, SIP_SSIZE_T);}
static void *copy_QGLShader_ShaderType(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new  ::QGLShader::ShaderType(reinterpret_cast<const  ::QGLShader::ShaderType *>(sipSrc)[sipSrcIdx]);
}


extern "C" {static void dealloc_QGLShader_ShaderType(sipSimpleWrapper *);}
static void dealloc_QGLShader_ShaderType(sipSimpleWrapper *sipSelf)
{
    if (sipIsOwnedByPython(sipSelf))
    {
        release_QGLShader_ShaderType(sipGetAddress(sipSelf), 0);
    }
}


extern "C" {static void *init_type_QGLShader_ShaderType(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QGLShader_ShaderType(sipSimpleWrapper *, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
     ::QGLShader::ShaderType *sipCpp = 0;

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new  ::QGLShader::ShaderType();
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    {
        int a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "i", &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new  ::QGLShader::ShaderType(a0);
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    {
        const  ::QGLShader::ShaderType* a0;
        int a0State = 0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J1", sipType_QGLShader_ShaderType, &a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new  ::QGLShader::ShaderType(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::QGLShader::ShaderType *>(a0),sipType_QGLShader_ShaderType,a0State);

            return sipCpp;
        }
    }

    return NULL;
}


extern "C" {static int convertTo_QGLShader_ShaderType(PyObject *, void **, int *, PyObject *);}
static int convertTo_QGLShader_ShaderType(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
     ::QGLShader::ShaderType **sipCppPtr = reinterpret_cast< ::QGLShader::ShaderType **>(sipCppPtrV);

#line 390 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qglobal.sip"
// Allow an instance of the base enum whenever a QGLShader::ShaderType is expected.

if (sipIsErr == NULL)
    return (PyObject_TypeCheck(sipPy, sipTypeAsPyTypeObject(sipType_QGLShader_ShaderTypeBit)) ||
            sipCanConvertToType(sipPy, sipType_QGLShader_ShaderType, SIP_NO_CONVERTORS));

if (PyObject_TypeCheck(sipPy, sipTypeAsPyTypeObject(sipType_QGLShader_ShaderTypeBit)))
{
    *sipCppPtr = new QGLShader::ShaderType(int(SIPLong_AsLong(sipPy)));

    return sipGetState(sipTransferObj);
}

*sipCppPtr = reinterpret_cast<QGLShader::ShaderType *>(sipConvertToType(sipPy, sipType_QGLShader_ShaderType, sipTransferObj, SIP_NO_CONVERTORS, 0, sipIsErr));

return 0;
#line 5369 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
}


/* Define this type's Python slots. */
static sipPySlotDef slots_QGLShader_ShaderType[] = {
    {(void *)slot_QGLShader_ShaderType___bool__, bool_slot},
    {(void *)slot_QGLShader_ShaderType___ne__, ne_slot},
    {(void *)slot_QGLShader_ShaderType___eq__, eq_slot},
    {(void *)slot_QGLShader_ShaderType___ixor__, ixor_slot},
    {(void *)slot_QGLShader_ShaderType___xor__, xor_slot},
    {(void *)slot_QGLShader_ShaderType___ior__, ior_slot},
    {(void *)slot_QGLShader_ShaderType___or__, or_slot},
    {(void *)slot_QGLShader_ShaderType___iand__, iand_slot},
    {(void *)slot_QGLShader_ShaderType___and__, and_slot},
    {(void *)slot_QGLShader_ShaderType___invert__, invert_slot},
    {(void *)slot_QGLShader_ShaderType___int__, int_slot},
    {0, (sipPySlotType)0}
};

PyDoc_STRVAR(doc_QGLShader_ShaderType, "\1QGLShader.ShaderType()\n"
"QGLShader.ShaderType(Union[QGLShader.ShaderType, QGLShader.ShaderTypeBit])\n"
"QGLShader.ShaderType(QGLShader.ShaderType)");


static pyqt4ClassPluginDef plugin_QGLShader_ShaderType = {
    0,
    1,
    0
};


sipClassTypeDef sipTypeDef_QtOpenGL_QGLShader_ShaderType = {
    {
        -1,
        0,
        0,
        SIP_TYPE_CLASS,
        sipNameNr_QGLShader__ShaderType,
        {0},
        &plugin_QGLShader_ShaderType
    },
    {
        sipNameNr_ShaderType,
        {19, 255, 0},
        0, 0,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QGLShader_ShaderType,
    sipNameNr_PyQt4_QtCore_pyqtWrapperType,
    sipNameNr_sip_simplewrapper,
    0,
    slots_QGLShader_ShaderType,
    init_type_QGLShader_ShaderType,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QGLShader_ShaderType,
    assign_QGLShader_ShaderType,
    array_QGLShader_ShaderType,
    copy_QGLShader_ShaderType,
    release_QGLShader_ShaderType,
    0,
    convertTo_QGLShader_ShaderType,
    0,
    0,
    0,
    0,
    0
};

#line 29 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qglshaderprogram.sip"
#include <qglshaderprogram.h>
#line 5455 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

#line 29 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qglshaderprogram.sip"
#include <qglshaderprogram.h>
#line 5459 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 29 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qobject.sip"
#include <qobject.h>
#line 5462 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 225 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qgl.sip"
#include <qgl.h>
#line 5465 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 27 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 5468 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 32 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 5471 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 5474 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 368 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 5477 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 351 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 5480 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 265 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 5483 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 5486 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 5489 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 115 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 5492 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qthread.sip"
#include <qthread.h>
#line 5495 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qregexp.sip"
#include <qregexp.h>
#line 5498 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 5501 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"


class sipQGLShader : public  ::QGLShader
{
public:
    sipQGLShader( ::QGLShader::ShaderType, ::QObject*);
    sipQGLShader( ::QGLShader::ShaderType,const  ::QGLContext*, ::QObject*);
    virtual ~sipQGLShader();

    int qt_metacall(QMetaObject::Call,int,void **);
    void *qt_metacast(const char *);
    const QMetaObject *metaObject() const;

    /*
     * There is a public method for every protected method visible from
     * this class.
     */
     ::QObject* sipProtect_sender() const;
    int sipProtect_receivers(const char*) const;
    void sipProtectVirt_timerEvent(bool, ::QTimerEvent*);
    void sipProtectVirt_childEvent(bool, ::QChildEvent*);
    void sipProtectVirt_customEvent(bool, ::QEvent*);
    void sipProtectVirt_connectNotify(bool,const char*);
    void sipProtectVirt_disconnectNotify(bool,const char*);
    int sipProtect_senderSignalIndex() const;

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
    bool event( ::QEvent*);
    bool eventFilter( ::QObject*, ::QEvent*);
    void timerEvent( ::QTimerEvent*);
    void childEvent( ::QChildEvent*);
    void customEvent( ::QEvent*);
    void connectNotify(const char*);
    void disconnectNotify(const char*);

public:
    sipSimpleWrapper *sipPySelf;

private:
    sipQGLShader(const sipQGLShader &);
    sipQGLShader &operator = (const sipQGLShader &);

    char sipPyMethods[7];
};

sipQGLShader::sipQGLShader( ::QGLShader::ShaderType a0, ::QObject*a1):  ::QGLShader(a0,a1), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQGLShader::sipQGLShader( ::QGLShader::ShaderType a0,const  ::QGLContext*a1, ::QObject*a2):  ::QGLShader(a0,a1,a2), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQGLShader::~sipQGLShader()
{
    sipInstanceDestroyedEx(&sipPySelf);
}

const QMetaObject *sipQGLShader::metaObject() const
{
    return sip_QtOpenGL_qt_metaobject(sipPySelf,sipType_QGLShader);
}

int sipQGLShader::qt_metacall(QMetaObject::Call _c,int _id,void **_a)
{
    _id =  ::QGLShader::qt_metacall(_c,_id,_a);

    if (_id >= 0)
        _id = sip_QtOpenGL_qt_metacall(sipPySelf,sipType_QGLShader,_c,_id,_a);

    return _id;
}

void *sipQGLShader::qt_metacast(const char *_clname)
{
    return (sip_QtOpenGL_qt_metacast(sipPySelf, sipType_QGLShader, _clname)) ? this :  ::QGLShader::qt_metacast(_clname);
}

bool sipQGLShader::event( ::QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[0],sipPySelf,NULL,sipName_event);

    if (!sipMeth)
        return  ::QGLShader::event(a0);

    extern bool sipVH_QtOpenGL_32(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QEvent*);

    return sipVH_QtOpenGL_32(sipGILState, 0, sipPySelf, sipMeth, a0);
}

bool sipQGLShader::eventFilter( ::QObject*a0, ::QEvent*a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[1],sipPySelf,NULL,sipName_eventFilter);

    if (!sipMeth)
        return  ::QGLShader::eventFilter(a0,a1);

    extern bool sipVH_QtOpenGL_33(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QObject*, ::QEvent*);

    return sipVH_QtOpenGL_33(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

void sipQGLShader::timerEvent( ::QTimerEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[2],sipPySelf,NULL,sipName_timerEvent);

    if (!sipMeth)
    {
         ::QGLShader::timerEvent(a0);
        return;
    }

    extern void sipVH_QtOpenGL_34(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QTimerEvent*);

    sipVH_QtOpenGL_34(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLShader::childEvent( ::QChildEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[3],sipPySelf,NULL,sipName_childEvent);

    if (!sipMeth)
    {
         ::QGLShader::childEvent(a0);
        return;
    }

    extern void sipVH_QtOpenGL_35(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QChildEvent*);

    sipVH_QtOpenGL_35(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLShader::customEvent( ::QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[4],sipPySelf,NULL,sipName_customEvent);

    if (!sipMeth)
    {
         ::QGLShader::customEvent(a0);
        return;
    }

    extern void sipVH_QtOpenGL_9(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QEvent*);

    sipVH_QtOpenGL_9(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLShader::connectNotify(const char*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[5],sipPySelf,NULL,sipName_connectNotify);

    if (!sipMeth)
    {
         ::QGLShader::connectNotify(a0);
        return;
    }

    extern void sipVH_QtOpenGL_36(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const char*);

    sipVH_QtOpenGL_36(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLShader::disconnectNotify(const char*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[6],sipPySelf,NULL,sipName_disconnectNotify);

    if (!sipMeth)
    {
         ::QGLShader::disconnectNotify(a0);
        return;
    }

    extern void sipVH_QtOpenGL_36(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const char*);

    sipVH_QtOpenGL_36(sipGILState, 0, sipPySelf, sipMeth, a0);
}

 ::QObject* sipQGLShader::sipProtect_sender() const
{
    return  ::QObject::sender();
}

int sipQGLShader::sipProtect_receivers(const char*a0) const
{
    return  ::QObject::receivers(a0);
}

void sipQGLShader::sipProtectVirt_timerEvent(bool sipSelfWasArg, ::QTimerEvent*a0)
{
    (sipSelfWasArg ?  ::QObject::timerEvent(a0) : timerEvent(a0));
}

void sipQGLShader::sipProtectVirt_childEvent(bool sipSelfWasArg, ::QChildEvent*a0)
{
    (sipSelfWasArg ?  ::QObject::childEvent(a0) : childEvent(a0));
}

void sipQGLShader::sipProtectVirt_customEvent(bool sipSelfWasArg, ::QEvent*a0)
{
    (sipSelfWasArg ?  ::QObject::customEvent(a0) : customEvent(a0));
}

void sipQGLShader::sipProtectVirt_connectNotify(bool sipSelfWasArg,const char*a0)
{
    (sipSelfWasArg ?  ::QObject::connectNotify(a0) : connectNotify(a0));
}

void sipQGLShader::sipProtectVirt_disconnectNotify(bool sipSelfWasArg,const char*a0)
{
    (sipSelfWasArg ?  ::QObject::disconnectNotify(a0) : disconnectNotify(a0));
}

int sipQGLShader::sipProtect_senderSignalIndex() const
{
    return  ::QObject::senderSignalIndex();
}


PyDoc_STRVAR(doc_QGLShader_sender, "sender(self) -> QObject");

extern "C" {static PyObject *meth_QGLShader_sender(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLShader_sender(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQGLShader *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QGLShader, &sipCpp))
        {
             ::QObject*sipRes = 0;

#line 678 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qobject.sip"
        typedef QObject *(*helper_func)(QObject *);
        
        static helper_func helper = 0;
        
        if (!helper)
        {
            helper = (helper_func)sipImportSymbol("qpycore_qobject_sender");
            Q_ASSERT(helper);
        }
        
        // sender() must be called without the GIL to avoid possible deadlocks between
        // the GIL and Qt's internal thread data mutex.
        
        Py_BEGIN_ALLOW_THREADS
        
        #if defined(SIP_PROTECTED_IS_PUBLIC)
        sipRes = sipCpp->sender();
        #else
        sipRes = sipCpp->sipProtect_sender();
        #endif
        
        Py_END_ALLOW_THREADS
        
        sipRes = helper(sipRes);
#line 5787 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

            return sipConvertFromType(sipRes,sipType_QObject,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShader, sipName_sender, doc_QGLShader_sender);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShader_receivers, "receivers(self, QT_SIGNAL) -> int");

extern "C" {static PyObject *meth_QGLShader_receivers(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLShader_receivers(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        PyObject * a0;
        const sipQGLShader *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BP0", &sipSelf, sipType_QGLShader, &sipCpp, &a0))
        {
            int sipRes = 0;
            sipErrorState sipError = sipErrorNone;

#line 706 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qobject.sip"
        // We need to take into account any proxies for Python signals. Import the
        // helpers if it hasn't already been done.
        typedef const char *(*pyqt4_get_signal_t)(PyObject *);
        typedef int (*receivers_helper_func)(QObject *, const char *, int);
        
        static pyqt4_get_signal_t pyqt4_get_signal = 0;
        static receivers_helper_func receivers_helper = 0;
        
        if (!pyqt4_get_signal)
        {
            pyqt4_get_signal = (pyqt4_get_signal_t)sipImportSymbol("pyqt4_get_signal");
            Q_ASSERT(pyqt4_get_signal);
        }
        
        if (!receivers_helper)
        {
            receivers_helper = (receivers_helper_func)sipImportSymbol("qpycore_qobject_receivers");
            Q_ASSERT(receivers_helper);
        }
        
        // PyQt5: Get rid of the const casts.
        const char *sig = pyqt4_get_signal(a0);
            
        if (sig)
        {
        #if defined(SIP_PROTECTED_IS_PUBLIC)
            sipRes = receivers_helper(const_cast<QObject *>(sipCpp), sig, sipCpp->receivers(sig));
        #else
            sipRes = receivers_helper(const_cast<QObject *>(static_cast<const QObject *>(sipCpp)), sig, sipCpp->sipProtect_receivers(sig));
        #endif
        }
        else
        {
            sipError = sipBadCallableArg(0, a0);
        }
#line 5853 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            return SIPLong_FromLong(sipRes);
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShader, sipName_receivers, doc_QGLShader_receivers);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShader_timerEvent, "timerEvent(self, QTimerEvent)");

extern "C" {static PyObject *meth_QGLShader_timerEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLShader_timerEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QTimerEvent* a0;
        sipQGLShader *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGLShader, &sipCpp, sipType_QTimerEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_timerEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShader, sipName_timerEvent, doc_QGLShader_timerEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShader_childEvent, "childEvent(self, QChildEvent)");

extern "C" {static PyObject *meth_QGLShader_childEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLShader_childEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QChildEvent* a0;
        sipQGLShader *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGLShader, &sipCpp, sipType_QChildEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_childEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShader, sipName_childEvent, doc_QGLShader_childEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShader_customEvent, "customEvent(self, QEvent)");

extern "C" {static PyObject *meth_QGLShader_customEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLShader_customEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QEvent* a0;
        sipQGLShader *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGLShader, &sipCpp, sipType_QEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_customEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShader, sipName_customEvent, doc_QGLShader_customEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShader_connectNotify, "connectNotify(self, QT_SIGNAL)");

extern "C" {static PyObject *meth_QGLShader_connectNotify(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLShader_connectNotify(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        PyObject * a0;
        sipQGLShader *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BP0", &sipSelf, sipType_QGLShader, &sipCpp, &a0))
        {
            sipErrorState sipError = sipErrorNone;

#line 752 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qobject.sip"
        typedef const char *(*pyqt4_get_signal_t)(PyObject *);
        
        static pyqt4_get_signal_t pyqt4_get_signal = 0;
        
        if (!pyqt4_get_signal)
        {
            pyqt4_get_signal = (pyqt4_get_signal_t)sipImportSymbol("pyqt4_get_signal");
            Q_ASSERT(pyqt4_get_signal);
        }
        
        const char *sig = pyqt4_get_signal(a0);
            
        if (sig)
        {
        #if defined(SIP_PROTECTED_IS_PUBLIC)
            (sipSelfWasArg ? sipCpp->QObject::connectNotify(sig) : sipCpp->connectNotify(sig));
        #else
            sipCpp->sipProtectVirt_connectNotify(sipSelfWasArg, sig);
        #endif
        }
        else
        {
            sipError = sipBadCallableArg(0, a0);
        }
#line 6009 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShader, sipName_connectNotify, doc_QGLShader_connectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShader_disconnectNotify, "disconnectNotify(self, QT_SIGNAL)");

extern "C" {static PyObject *meth_QGLShader_disconnectNotify(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLShader_disconnectNotify(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        PyObject * a0;
        sipQGLShader *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BP0", &sipSelf, sipType_QGLShader, &sipCpp, &a0))
        {
            sipErrorState sipError = sipErrorNone;

#line 785 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qobject.sip"
        typedef const char *(*pyqt4_get_signal_t)(PyObject *);
        
        static pyqt4_get_signal_t pyqt4_get_signal = 0;
        
        if (!pyqt4_get_signal)
        {
            pyqt4_get_signal = (pyqt4_get_signal_t)sipImportSymbol("pyqt4_get_signal");
            Q_ASSERT(pyqt4_get_signal);
        }
        
        const char *sig = pyqt4_get_signal(a0);
            
        if (sig)
        {
        #if defined(SIP_PROTECTED_IS_PUBLIC)
            (sipSelfWasArg ? sipCpp->QObject::disconnectNotify(sig) : sipCpp->disconnectNotify(sig));
        #else
            sipCpp->sipProtectVirt_disconnectNotify(sipSelfWasArg, sig);
        #endif
        }
        else
        {
            sipError = sipBadCallableArg(0, a0);
        }
#line 6073 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShader, sipName_disconnectNotify, doc_QGLShader_disconnectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShader_senderSignalIndex, "senderSignalIndex(self) -> int");

extern "C" {static PyObject *meth_QGLShader_senderSignalIndex(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLShader_senderSignalIndex(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQGLShader *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QGLShader, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_senderSignalIndex();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShader, sipName_senderSignalIndex, doc_QGLShader_senderSignalIndex);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShader_shaderType, "shaderType(self) -> QGLShader.ShaderType");

extern "C" {static PyObject *meth_QGLShader_shaderType(PyObject *, PyObject *);}
static PyObject *meth_QGLShader_shaderType(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLShader *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLShader, &sipCpp))
        {
             ::QGLShader::ShaderType*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QGLShader::ShaderType(sipCpp->shaderType());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QGLShader_ShaderType,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShader, sipName_shaderType, doc_QGLShader_shaderType);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShader_compileSourceCode, "compileSourceCode(self, Union[QByteArray, bytes, bytearray]) -> bool\n"
"compileSourceCode(self, str) -> bool");

extern "C" {static PyObject *meth_QGLShader_compileSourceCode(PyObject *, PyObject *);}
static PyObject *meth_QGLShader_compileSourceCode(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QByteArray* a0;
        int a0State = 0;
         ::QGLShader *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QGLShader, &sipCpp, sipType_QByteArray, &a0, &a0State))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->compileSourceCode(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::QByteArray *>(a0),sipType_QByteArray,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    {
        const  ::QString* a0;
        int a0State = 0;
         ::QGLShader *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QGLShader, &sipCpp, sipType_QString,&a0, &a0State))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->compileSourceCode(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShader, sipName_compileSourceCode, doc_QGLShader_compileSourceCode);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShader_compileSourceFile, "compileSourceFile(self, str) -> bool");

extern "C" {static PyObject *meth_QGLShader_compileSourceFile(PyObject *, PyObject *);}
static PyObject *meth_QGLShader_compileSourceFile(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QString* a0;
        int a0State = 0;
         ::QGLShader *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QGLShader, &sipCpp, sipType_QString,&a0, &a0State))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->compileSourceFile(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShader, sipName_compileSourceFile, doc_QGLShader_compileSourceFile);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShader_sourceCode, "sourceCode(self) -> QByteArray");

extern "C" {static PyObject *meth_QGLShader_sourceCode(PyObject *, PyObject *);}
static PyObject *meth_QGLShader_sourceCode(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLShader *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLShader, &sipCpp))
        {
             ::QByteArray*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QByteArray(sipCpp->sourceCode());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QByteArray,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShader, sipName_sourceCode, doc_QGLShader_sourceCode);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShader_isCompiled, "isCompiled(self) -> bool");

extern "C" {static PyObject *meth_QGLShader_isCompiled(PyObject *, PyObject *);}
static PyObject *meth_QGLShader_isCompiled(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLShader *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLShader, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isCompiled();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShader, sipName_isCompiled, doc_QGLShader_isCompiled);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShader_log, "log(self) -> str");

extern "C" {static PyObject *meth_QGLShader_log(PyObject *, PyObject *);}
static PyObject *meth_QGLShader_log(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLShader *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLShader, &sipCpp))
        {
             ::QString*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QString(sipCpp->log());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QString,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShader, sipName_log, doc_QGLShader_log);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShader_shaderId, "shaderId(self) -> int");

extern "C" {static PyObject *meth_QGLShader_shaderId(PyObject *, PyObject *);}
static PyObject *meth_QGLShader_shaderId(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLShader *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLShader, &sipCpp))
        {
             ::GLuint sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->shaderId();
            Py_END_ALLOW_THREADS

            return PyLong_FromUnsignedLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShader, sipName_shaderId, doc_QGLShader_shaderId);

    return NULL;
}


PyDoc_STRVAR(doc_QGLShader_hasOpenGLShaders, "hasOpenGLShaders(QGLShader.ShaderType, context: QGLContext = None) -> bool");

extern "C" {static PyObject *meth_QGLShader_hasOpenGLShaders(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLShader_hasOpenGLShaders(PyObject *, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLShader::ShaderType* a0;
        int a0State = 0;
        const  ::QGLContext* a1 = 0;

        static const char *sipKwdList[] = {
            NULL,
            sipName_context,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "J1|J8", sipType_QGLShader_ShaderType, &a0, &a0State, sipType_QGLContext, &a1))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes =  ::QGLShader::hasOpenGLShaders(*a0,a1);
            Py_END_ALLOW_THREADS
            sipReleaseType(a0,sipType_QGLShader_ShaderType,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLShader, sipName_hasOpenGLShaders, doc_QGLShader_hasOpenGLShaders);

    return NULL;
}


/* Cast a pointer to a type somewhere in its inheritance hierarchy. */
extern "C" {static void *cast_QGLShader(void *, const sipTypeDef *);}
static void *cast_QGLShader(void *sipCppV, const sipTypeDef *targetType)
{
     ::QGLShader *sipCpp = reinterpret_cast< ::QGLShader *>(sipCppV);

    if (targetType == sipType_QObject)
        return static_cast< ::QObject *>(sipCpp);

    return sipCppV;
}


/* Call the instance's destructor. */
extern "C" {static void release_QGLShader(void *, int);}
static void release_QGLShader(void *sipCppV, int)
{
     ::QGLShader *sipCpp = reinterpret_cast< ::QGLShader *>(sipCppV);

    Py_BEGIN_ALLOW_THREADS

    if (QThread::currentThread() == sipCpp->thread())
        delete sipCpp;
    else
        sipCpp->deleteLater();

    Py_END_ALLOW_THREADS
}


extern "C" {static void dealloc_QGLShader(sipSimpleWrapper *);}
static void dealloc_QGLShader(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerivedClass(sipSelf))
        reinterpret_cast<sipQGLShader *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsOwnedByPython(sipSelf))
    {
        release_QGLShader(sipGetAddress(sipSelf), sipIsDerivedClass(sipSelf));
    }
}


extern "C" {static void *init_type_QGLShader(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QGLShader(sipSimpleWrapper *sipSelf, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **sipOwner, PyObject **sipParseErr)
{
    sipQGLShader *sipCpp = 0;

    {
         ::QGLShader::ShaderType* a0;
        int a0State = 0;
         ::QObject* a1 = 0;

        static const char *sipKwdList[] = {
            NULL,
            sipName_parent,
        };

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "J1|JH", sipType_QGLShader_ShaderType, &a0, &a0State, sipType_QObject, &a1, sipOwner))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQGLShader(*a0,a1);
            Py_END_ALLOW_THREADS
            sipReleaseType(a0,sipType_QGLShader_ShaderType,a0State);

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    {
         ::QGLShader::ShaderType* a0;
        int a0State = 0;
        const  ::QGLContext* a1;
         ::QObject* a2 = 0;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_parent,
        };

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "J1J8|JH", sipType_QGLShader_ShaderType, &a0, &a0State, sipType_QGLContext, &a1, sipType_QObject, &a2, sipOwner))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQGLShader(*a0,a1,a2);
            Py_END_ALLOW_THREADS
            sipReleaseType(a0,sipType_QGLShader_ShaderType,a0State);

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's super-types. */
static sipEncodedTypeDef supers_QGLShader[] = {{3, 0, 1}};


static PyMethodDef methods_QGLShader[] = {
    {SIP_MLNAME_CAST(sipName_childEvent), (PyCFunction)meth_QGLShader_childEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_compileSourceCode), meth_QGLShader_compileSourceCode, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLShader_compileSourceCode)},
    {SIP_MLNAME_CAST(sipName_compileSourceFile), meth_QGLShader_compileSourceFile, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLShader_compileSourceFile)},
    {SIP_MLNAME_CAST(sipName_connectNotify), (PyCFunction)meth_QGLShader_connectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_customEvent), (PyCFunction)meth_QGLShader_customEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_disconnectNotify), (PyCFunction)meth_QGLShader_disconnectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_hasOpenGLShaders), (PyCFunction)meth_QGLShader_hasOpenGLShaders, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLShader_hasOpenGLShaders)},
    {SIP_MLNAME_CAST(sipName_isCompiled), meth_QGLShader_isCompiled, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLShader_isCompiled)},
    {SIP_MLNAME_CAST(sipName_log), meth_QGLShader_log, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLShader_log)},
    {SIP_MLNAME_CAST(sipName_receivers), (PyCFunction)meth_QGLShader_receivers, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_sender), (PyCFunction)meth_QGLShader_sender, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_senderSignalIndex), (PyCFunction)meth_QGLShader_senderSignalIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_shaderId), meth_QGLShader_shaderId, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLShader_shaderId)},
    {SIP_MLNAME_CAST(sipName_shaderType), meth_QGLShader_shaderType, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLShader_shaderType)},
    {SIP_MLNAME_CAST(sipName_sourceCode), meth_QGLShader_sourceCode, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLShader_sourceCode)},
    {SIP_MLNAME_CAST(sipName_timerEvent), (PyCFunction)meth_QGLShader_timerEvent, METH_VARARGS|METH_KEYWORDS, NULL}
};

static sipEnumMemberDef enummembers_QGLShader[] = {
    {sipName_Fragment, static_cast<int>( ::QGLShader::Fragment), 21},
    {sipName_Geometry, static_cast<int>( ::QGLShader::Geometry), 21},
    {sipName_Vertex, static_cast<int>( ::QGLShader::Vertex), 21},
};

PyDoc_STRVAR(doc_QGLShader, "\1QGLShader(QGLShader.ShaderType, parent: QObject = None)\n"
"QGLShader(QGLShader.ShaderType, QGLContext, parent: QObject = None)");


static pyqt4ClassPluginDef plugin_QGLShader = {
    & ::QGLShader::staticMetaObject,
    0,
    0
};


sipClassTypeDef sipTypeDef_QtOpenGL_QGLShader = {
    {
        -1,
        0,
        0,
        SIP_TYPE_SCC|SIP_TYPE_CLASS,
        sipNameNr_QGLShader,
        {0},
        &plugin_QGLShader
    },
    {
        sipNameNr_QGLShader,
        {0, 0, 1},
        16, methods_QGLShader,
        3, enummembers_QGLShader,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QGLShader,
    -1,
    -1,
    supers_QGLShader,
    0,
    init_type_QGLShader,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QGLShader,
    0,
    0,
    0,
    release_QGLShader,
    cast_QGLShader,
    0,
    0,
    0,
    0,
    0,
    0
};

#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qglpixelbuffer.sip"
#include <qglpixelbuffer.h>
#line 6592 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qsize.sip"
#include <qsize.h>
#line 6596 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 70 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qgl.sip"
#include <qgl.h>
#line 6599 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 322 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qgl.sip"
#include <qgl.h>
#line 6602 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qpaintdevice.sip"
#include <qpaintdevice.h>
#line 6605 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 52 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qpaintengine.sip"
#include <qpaintengine.h>
#line 6608 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qimage.sip"
#include <qimage.h>
#line 6611 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 159 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qrect.sip"
#include <qrect.h>
#line 6614 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 110 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qpoint.sip"
#include <qpoint.h>
#line 6617 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qpixmap.sip"
#include <qpixmap.h>
#line 6620 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 27 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 6623 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"


class sipQGLPixelBuffer : public  ::QGLPixelBuffer
{
public:
    sipQGLPixelBuffer(const  ::QSize&,const  ::QGLFormat&, ::QGLWidget*);
    sipQGLPixelBuffer(int,int,const  ::QGLFormat&, ::QGLWidget*);
    virtual ~sipQGLPixelBuffer();

    /*
     * There is a public method for every protected method visible from
     * this class.
     */
    int sipProtectVirt_metric(bool, ::QPaintDevice::PaintDeviceMetric) const;
    int sipProtectVirt_devType(bool) const;

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
    int devType() const;
     ::QPaintEngine* paintEngine() const;
    int metric( ::QPaintDevice::PaintDeviceMetric) const;

public:
    sipSimpleWrapper *sipPySelf;

private:
    sipQGLPixelBuffer(const sipQGLPixelBuffer &);
    sipQGLPixelBuffer &operator = (const sipQGLPixelBuffer &);

    char sipPyMethods[3];
};

sipQGLPixelBuffer::sipQGLPixelBuffer(const  ::QSize& a0,const  ::QGLFormat& a1, ::QGLWidget*a2):  ::QGLPixelBuffer(a0,a1,a2), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQGLPixelBuffer::sipQGLPixelBuffer(int a0,int a1,const  ::QGLFormat& a2, ::QGLWidget*a3):  ::QGLPixelBuffer(a0,a1,a2,a3), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQGLPixelBuffer::~sipQGLPixelBuffer()
{
    sipInstanceDestroyedEx(&sipPySelf);
}

int sipQGLPixelBuffer::devType() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[0]),sipPySelf,NULL,sipName_devType);

    if (!sipMeth)
        return  ::QGLPixelBuffer::devType();

    extern int sipVH_QtOpenGL_29(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH_QtOpenGL_29(sipGILState, 0, sipPySelf, sipMeth);
}

 ::QPaintEngine* sipQGLPixelBuffer::paintEngine() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[1]),sipPySelf,NULL,sipName_paintEngine);

    if (!sipMeth)
        return  ::QGLPixelBuffer::paintEngine();

    extern  ::QPaintEngine* sipVH_QtOpenGL_30(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH_QtOpenGL_30(sipGILState, 0, sipPySelf, sipMeth);
}

int sipQGLPixelBuffer::metric( ::QPaintDevice::PaintDeviceMetric a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[2]),sipPySelf,NULL,sipName_metric);

    if (!sipMeth)
        return  ::QGLPixelBuffer::metric(a0);

    extern int sipVH_QtOpenGL_31(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QPaintDevice::PaintDeviceMetric);

    return sipVH_QtOpenGL_31(sipGILState, 0, sipPySelf, sipMeth, a0);
}

int sipQGLPixelBuffer::sipProtectVirt_metric(bool sipSelfWasArg, ::QPaintDevice::PaintDeviceMetric a0) const
{
    return (sipSelfWasArg ?  ::QGLPixelBuffer::metric(a0) : metric(a0));
}

int sipQGLPixelBuffer::sipProtectVirt_devType(bool sipSelfWasArg) const
{
    return (sipSelfWasArg ?  ::QGLPixelBuffer::devType() : devType());
}


PyDoc_STRVAR(doc_QGLPixelBuffer_isValid, "isValid(self) -> bool");

extern "C" {static PyObject *meth_QGLPixelBuffer_isValid(PyObject *, PyObject *);}
static PyObject *meth_QGLPixelBuffer_isValid(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLPixelBuffer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLPixelBuffer, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isValid();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLPixelBuffer, sipName_isValid, doc_QGLPixelBuffer_isValid);

    return NULL;
}


PyDoc_STRVAR(doc_QGLPixelBuffer_makeCurrent, "makeCurrent(self) -> bool");

extern "C" {static PyObject *meth_QGLPixelBuffer_makeCurrent(PyObject *, PyObject *);}
static PyObject *meth_QGLPixelBuffer_makeCurrent(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLPixelBuffer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLPixelBuffer, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->makeCurrent();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLPixelBuffer, sipName_makeCurrent, doc_QGLPixelBuffer_makeCurrent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLPixelBuffer_doneCurrent, "doneCurrent(self) -> bool");

extern "C" {static PyObject *meth_QGLPixelBuffer_doneCurrent(PyObject *, PyObject *);}
static PyObject *meth_QGLPixelBuffer_doneCurrent(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLPixelBuffer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLPixelBuffer, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->doneCurrent();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLPixelBuffer, sipName_doneCurrent, doc_QGLPixelBuffer_doneCurrent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLPixelBuffer_generateDynamicTexture, "generateDynamicTexture(self) -> int");

extern "C" {static PyObject *meth_QGLPixelBuffer_generateDynamicTexture(PyObject *, PyObject *);}
static PyObject *meth_QGLPixelBuffer_generateDynamicTexture(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLPixelBuffer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLPixelBuffer, &sipCpp))
        {
             ::GLuint sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->generateDynamicTexture();
            Py_END_ALLOW_THREADS

            return PyLong_FromUnsignedLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLPixelBuffer, sipName_generateDynamicTexture, doc_QGLPixelBuffer_generateDynamicTexture);

    return NULL;
}


PyDoc_STRVAR(doc_QGLPixelBuffer_bindToDynamicTexture, "bindToDynamicTexture(self, int) -> bool");

extern "C" {static PyObject *meth_QGLPixelBuffer_bindToDynamicTexture(PyObject *, PyObject *);}
static PyObject *meth_QGLPixelBuffer_bindToDynamicTexture(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::GLuint a0;
         ::QGLPixelBuffer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QGLPixelBuffer, &sipCpp, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->bindToDynamicTexture(a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLPixelBuffer, sipName_bindToDynamicTexture, doc_QGLPixelBuffer_bindToDynamicTexture);

    return NULL;
}


PyDoc_STRVAR(doc_QGLPixelBuffer_releaseFromDynamicTexture, "releaseFromDynamicTexture(self)");

extern "C" {static PyObject *meth_QGLPixelBuffer_releaseFromDynamicTexture(PyObject *, PyObject *);}
static PyObject *meth_QGLPixelBuffer_releaseFromDynamicTexture(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLPixelBuffer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLPixelBuffer, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->releaseFromDynamicTexture();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLPixelBuffer, sipName_releaseFromDynamicTexture, doc_QGLPixelBuffer_releaseFromDynamicTexture);

    return NULL;
}


PyDoc_STRVAR(doc_QGLPixelBuffer_updateDynamicTexture, "updateDynamicTexture(self, int)");

extern "C" {static PyObject *meth_QGLPixelBuffer_updateDynamicTexture(PyObject *, PyObject *);}
static PyObject *meth_QGLPixelBuffer_updateDynamicTexture(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::GLuint a0;
        const  ::QGLPixelBuffer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QGLPixelBuffer, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->updateDynamicTexture(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLPixelBuffer, sipName_updateDynamicTexture, doc_QGLPixelBuffer_updateDynamicTexture);

    return NULL;
}


PyDoc_STRVAR(doc_QGLPixelBuffer_bindTexture, "bindTexture(self, QImage, target: int = GL_TEXTURE_2D) -> int\n"
"bindTexture(self, QPixmap, target: int = GL_TEXTURE_2D) -> int\n"
"bindTexture(self, str) -> int");

extern "C" {static PyObject *meth_QGLPixelBuffer_bindTexture(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLPixelBuffer_bindTexture(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QImage* a0;
         ::GLenum a1 = GL_TEXTURE_2D;
         ::QGLPixelBuffer *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            sipName_target,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ9|u", &sipSelf, sipType_QGLPixelBuffer, &sipCpp, sipType_QImage, &a0, &a1))
        {
             ::GLuint sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->bindTexture(*a0,a1);
            Py_END_ALLOW_THREADS

            return PyLong_FromUnsignedLong(sipRes);
        }
    }

    {
        const  ::QPixmap* a0;
         ::GLenum a1 = GL_TEXTURE_2D;
         ::QGLPixelBuffer *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            sipName_target,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ9|u", &sipSelf, sipType_QGLPixelBuffer, &sipCpp, sipType_QPixmap, &a0, &a1))
        {
             ::GLuint sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->bindTexture(*a0,a1);
            Py_END_ALLOW_THREADS

            return PyLong_FromUnsignedLong(sipRes);
        }
    }

    {
        const  ::QString* a0;
        int a0State = 0;
         ::QGLPixelBuffer *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ1", &sipSelf, sipType_QGLPixelBuffer, &sipCpp, sipType_QString,&a0, &a0State))
        {
             ::GLuint sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->bindTexture(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);

            return PyLong_FromUnsignedLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLPixelBuffer, sipName_bindTexture, doc_QGLPixelBuffer_bindTexture);

    return NULL;
}


PyDoc_STRVAR(doc_QGLPixelBuffer_drawTexture, "drawTexture(self, QRectF, int, textureTarget: int = GL_TEXTURE_2D)\n"
"drawTexture(self, Union[QPointF, QPoint], int, textureTarget: int = GL_TEXTURE_2D)");

extern "C" {static PyObject *meth_QGLPixelBuffer_drawTexture(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLPixelBuffer_drawTexture(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QRectF* a0;
         ::GLuint a1;
         ::GLenum a2 = GL_TEXTURE_2D;
         ::QGLPixelBuffer *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_textureTarget,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ9u|u", &sipSelf, sipType_QGLPixelBuffer, &sipCpp, sipType_QRectF, &a0, &a1, &a2))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->drawTexture(*a0,a1,a2);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const  ::QPointF* a0;
        int a0State = 0;
         ::GLuint a1;
         ::GLenum a2 = GL_TEXTURE_2D;
         ::QGLPixelBuffer *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_textureTarget,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ1u|u", &sipSelf, sipType_QGLPixelBuffer, &sipCpp, sipType_QPointF, &a0, &a0State, &a1, &a2))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->drawTexture(*a0,a1,a2);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::QPointF *>(a0),sipType_QPointF,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLPixelBuffer, sipName_drawTexture, doc_QGLPixelBuffer_drawTexture);

    return NULL;
}


PyDoc_STRVAR(doc_QGLPixelBuffer_deleteTexture, "deleteTexture(self, int)");

extern "C" {static PyObject *meth_QGLPixelBuffer_deleteTexture(PyObject *, PyObject *);}
static PyObject *meth_QGLPixelBuffer_deleteTexture(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::GLuint a0;
         ::QGLPixelBuffer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QGLPixelBuffer, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->deleteTexture(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLPixelBuffer, sipName_deleteTexture, doc_QGLPixelBuffer_deleteTexture);

    return NULL;
}


PyDoc_STRVAR(doc_QGLPixelBuffer_size, "size(self) -> QSize");

extern "C" {static PyObject *meth_QGLPixelBuffer_size(PyObject *, PyObject *);}
static PyObject *meth_QGLPixelBuffer_size(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLPixelBuffer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLPixelBuffer, &sipCpp))
        {
             ::QSize*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QSize(sipCpp->size());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QSize,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLPixelBuffer, sipName_size, doc_QGLPixelBuffer_size);

    return NULL;
}


PyDoc_STRVAR(doc_QGLPixelBuffer_handle, "handle(self) -> int");

extern "C" {static PyObject *meth_QGLPixelBuffer_handle(PyObject *, PyObject *);}
static PyObject *meth_QGLPixelBuffer_handle(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLPixelBuffer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLPixelBuffer, &sipCpp))
        {
             ::Qt::HANDLE sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->handle();
            Py_END_ALLOW_THREADS

            return PyLong_FromUnsignedLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLPixelBuffer, sipName_handle, doc_QGLPixelBuffer_handle);

    return NULL;
}


PyDoc_STRVAR(doc_QGLPixelBuffer_toImage, "toImage(self) -> QImage");

extern "C" {static PyObject *meth_QGLPixelBuffer_toImage(PyObject *, PyObject *);}
static PyObject *meth_QGLPixelBuffer_toImage(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLPixelBuffer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLPixelBuffer, &sipCpp))
        {
             ::QImage*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QImage(sipCpp->toImage());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QImage,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLPixelBuffer, sipName_toImage, doc_QGLPixelBuffer_toImage);

    return NULL;
}


PyDoc_STRVAR(doc_QGLPixelBuffer_paintEngine, "paintEngine(self) -> QPaintEngine");

extern "C" {static PyObject *meth_QGLPixelBuffer_paintEngine(PyObject *, PyObject *);}
static PyObject *meth_QGLPixelBuffer_paintEngine(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        const  ::QGLPixelBuffer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLPixelBuffer, &sipCpp))
        {
             ::QPaintEngine*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp-> ::QGLPixelBuffer::paintEngine() : sipCpp->paintEngine());
            Py_END_ALLOW_THREADS

            return sipConvertFromType(sipRes,sipType_QPaintEngine,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLPixelBuffer, sipName_paintEngine, doc_QGLPixelBuffer_paintEngine);

    return NULL;
}


PyDoc_STRVAR(doc_QGLPixelBuffer_format, "format(self) -> QGLFormat");

extern "C" {static PyObject *meth_QGLPixelBuffer_format(PyObject *, PyObject *);}
static PyObject *meth_QGLPixelBuffer_format(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLPixelBuffer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLPixelBuffer, &sipCpp))
        {
             ::QGLFormat*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QGLFormat(sipCpp->format());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QGLFormat,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLPixelBuffer, sipName_format, doc_QGLPixelBuffer_format);

    return NULL;
}


PyDoc_STRVAR(doc_QGLPixelBuffer_hasOpenGLPbuffers, "hasOpenGLPbuffers() -> bool");

extern "C" {static PyObject *meth_QGLPixelBuffer_hasOpenGLPbuffers(PyObject *, PyObject *);}
static PyObject *meth_QGLPixelBuffer_hasOpenGLPbuffers(PyObject *, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        if (sipParseArgs(&sipParseErr, sipArgs, ""))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes =  ::QGLPixelBuffer::hasOpenGLPbuffers();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLPixelBuffer, sipName_hasOpenGLPbuffers, doc_QGLPixelBuffer_hasOpenGLPbuffers);

    return NULL;
}


PyDoc_STRVAR(doc_QGLPixelBuffer_metric, "metric(self, QPaintDevice.PaintDeviceMetric) -> int");

extern "C" {static PyObject *meth_QGLPixelBuffer_metric(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLPixelBuffer_metric(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QPaintDevice::PaintDeviceMetric a0;
        const sipQGLPixelBuffer *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BE", &sipSelf, sipType_QGLPixelBuffer, &sipCpp, sipType_QPaintDevice_PaintDeviceMetric, &a0))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtectVirt_metric(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLPixelBuffer, sipName_metric, doc_QGLPixelBuffer_metric);

    return NULL;
}


PyDoc_STRVAR(doc_QGLPixelBuffer_devType, "devType(self) -> int");

extern "C" {static PyObject *meth_QGLPixelBuffer_devType(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLPixelBuffer_devType(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        const sipQGLPixelBuffer *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QGLPixelBuffer, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtectVirt_devType(sipSelfWasArg);
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLPixelBuffer, sipName_devType, doc_QGLPixelBuffer_devType);

    return NULL;
}


/* Cast a pointer to a type somewhere in its inheritance hierarchy. */
extern "C" {static void *cast_QGLPixelBuffer(void *, const sipTypeDef *);}
static void *cast_QGLPixelBuffer(void *sipCppV, const sipTypeDef *targetType)
{
     ::QGLPixelBuffer *sipCpp = reinterpret_cast< ::QGLPixelBuffer *>(sipCppV);

    if (targetType == sipType_QPaintDevice)
        return static_cast< ::QPaintDevice *>(sipCpp);

    return sipCppV;
}


/* Call the instance's destructor. */
extern "C" {static void release_QGLPixelBuffer(void *, int);}
static void release_QGLPixelBuffer(void *sipCppV, int sipState)
{
    Py_BEGIN_ALLOW_THREADS

    if (sipState & SIP_DERIVED_CLASS)
        delete reinterpret_cast<sipQGLPixelBuffer *>(sipCppV);
    else
        delete reinterpret_cast< ::QGLPixelBuffer *>(sipCppV);

    Py_END_ALLOW_THREADS
}


extern "C" {static void dealloc_QGLPixelBuffer(sipSimpleWrapper *);}
static void dealloc_QGLPixelBuffer(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerivedClass(sipSelf))
        reinterpret_cast<sipQGLPixelBuffer *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsOwnedByPython(sipSelf))
    {
        release_QGLPixelBuffer(sipGetAddress(sipSelf), sipIsDerivedClass(sipSelf));
    }
}


extern "C" {static void *init_type_QGLPixelBuffer(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QGLPixelBuffer(sipSimpleWrapper *sipSelf, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
    sipQGLPixelBuffer *sipCpp = 0;

    {
        const  ::QSize* a0;
        const  ::QGLFormat& a1def = QGLFormat::defaultFormat();
        const  ::QGLFormat* a1 = &a1def;
         ::QGLWidget* a2 = 0;

        static const char *sipKwdList[] = {
            NULL,
            sipName_format,
            sipName_shareWidget,
        };

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "J9|J9J8", sipType_QSize, &a0, sipType_QGLFormat, &a1, sipType_QGLWidget, &a2))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQGLPixelBuffer(*a0,*a1,a2);
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    {
        int a0;
        int a1;
        const  ::QGLFormat& a2def = QGLFormat::defaultFormat();
        const  ::QGLFormat* a2 = &a2def;
         ::QGLWidget* a3 = 0;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_format,
            sipName_shareWidget,
        };

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "ii|J9J8", &a0, &a1, sipType_QGLFormat, &a2, sipType_QGLWidget, &a3))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQGLPixelBuffer(a0,a1,*a2,a3);
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's super-types. */
static sipEncodedTypeDef supers_QGLPixelBuffer[] = {{25, 1, 1}};


static PyMethodDef methods_QGLPixelBuffer[] = {
    {SIP_MLNAME_CAST(sipName_bindTexture), (PyCFunction)meth_QGLPixelBuffer_bindTexture, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLPixelBuffer_bindTexture)},
    {SIP_MLNAME_CAST(sipName_bindToDynamicTexture), meth_QGLPixelBuffer_bindToDynamicTexture, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLPixelBuffer_bindToDynamicTexture)},
    {SIP_MLNAME_CAST(sipName_deleteTexture), meth_QGLPixelBuffer_deleteTexture, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLPixelBuffer_deleteTexture)},
    {SIP_MLNAME_CAST(sipName_devType), (PyCFunction)meth_QGLPixelBuffer_devType, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLPixelBuffer_devType)},
    {SIP_MLNAME_CAST(sipName_doneCurrent), meth_QGLPixelBuffer_doneCurrent, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLPixelBuffer_doneCurrent)},
    {SIP_MLNAME_CAST(sipName_drawTexture), (PyCFunction)meth_QGLPixelBuffer_drawTexture, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLPixelBuffer_drawTexture)},
    {SIP_MLNAME_CAST(sipName_format), meth_QGLPixelBuffer_format, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLPixelBuffer_format)},
    {SIP_MLNAME_CAST(sipName_generateDynamicTexture), meth_QGLPixelBuffer_generateDynamicTexture, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLPixelBuffer_generateDynamicTexture)},
    {SIP_MLNAME_CAST(sipName_handle), meth_QGLPixelBuffer_handle, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLPixelBuffer_handle)},
    {SIP_MLNAME_CAST(sipName_hasOpenGLPbuffers), meth_QGLPixelBuffer_hasOpenGLPbuffers, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLPixelBuffer_hasOpenGLPbuffers)},
    {SIP_MLNAME_CAST(sipName_isValid), meth_QGLPixelBuffer_isValid, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLPixelBuffer_isValid)},
    {SIP_MLNAME_CAST(sipName_makeCurrent), meth_QGLPixelBuffer_makeCurrent, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLPixelBuffer_makeCurrent)},
    {SIP_MLNAME_CAST(sipName_metric), (PyCFunction)meth_QGLPixelBuffer_metric, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLPixelBuffer_metric)},
    {SIP_MLNAME_CAST(sipName_paintEngine), meth_QGLPixelBuffer_paintEngine, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLPixelBuffer_paintEngine)},
    {SIP_MLNAME_CAST(sipName_releaseFromDynamicTexture), meth_QGLPixelBuffer_releaseFromDynamicTexture, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLPixelBuffer_releaseFromDynamicTexture)},
    {SIP_MLNAME_CAST(sipName_size), meth_QGLPixelBuffer_size, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLPixelBuffer_size)},
    {SIP_MLNAME_CAST(sipName_toImage), meth_QGLPixelBuffer_toImage, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLPixelBuffer_toImage)},
    {SIP_MLNAME_CAST(sipName_updateDynamicTexture), meth_QGLPixelBuffer_updateDynamicTexture, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLPixelBuffer_updateDynamicTexture)}
};

PyDoc_STRVAR(doc_QGLPixelBuffer, "\1QGLPixelBuffer(QSize, format: QGLFormat = QGLFormat.defaultFormat(), shareWidget: QGLWidget = None)\n"
"QGLPixelBuffer(int, int, format: QGLFormat = QGLFormat.defaultFormat(), shareWidget: QGLWidget = None)");


static pyqt4ClassPluginDef plugin_QGLPixelBuffer = {
    0,
    0,
    0
};


sipClassTypeDef sipTypeDef_QtOpenGL_QGLPixelBuffer = {
    {
        -1,
        0,
        0,
        SIP_TYPE_CLASS,
        sipNameNr_QGLPixelBuffer,
        {0},
        &plugin_QGLPixelBuffer
    },
    {
        sipNameNr_QGLPixelBuffer,
        {0, 0, 1},
        18, methods_QGLPixelBuffer,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QGLPixelBuffer,
    -1,
    -1,
    supers_QGLPixelBuffer,
    0,
    init_type_QGLPixelBuffer,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QGLPixelBuffer,
    0,
    0,
    0,
    release_QGLPixelBuffer,
    cast_QGLPixelBuffer,
    0,
    0,
    0,
    0,
    0,
    0
};

#line 117 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qglframebufferobject.sip"
#include <qglframebufferobject.h>
#line 7547 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

#line 29 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qglframebufferobject.sip"
#include <qglframebufferobject.h>
#line 7551 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"


PyDoc_STRVAR(doc_QGLFramebufferObjectFormat_setSamples, "setSamples(self, int)");

extern "C" {static PyObject *meth_QGLFramebufferObjectFormat_setSamples(PyObject *, PyObject *);}
static PyObject *meth_QGLFramebufferObjectFormat_setSamples(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
         ::QGLFramebufferObjectFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QGLFramebufferObjectFormat, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setSamples(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFramebufferObjectFormat, sipName_setSamples, doc_QGLFramebufferObjectFormat_setSamples);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFramebufferObjectFormat_samples, "samples(self) -> int");

extern "C" {static PyObject *meth_QGLFramebufferObjectFormat_samples(PyObject *, PyObject *);}
static PyObject *meth_QGLFramebufferObjectFormat_samples(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFramebufferObjectFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLFramebufferObjectFormat, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->samples();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFramebufferObjectFormat, sipName_samples, doc_QGLFramebufferObjectFormat_samples);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFramebufferObjectFormat_setAttachment, "setAttachment(self, QGLFramebufferObject.Attachment)");

extern "C" {static PyObject *meth_QGLFramebufferObjectFormat_setAttachment(PyObject *, PyObject *);}
static PyObject *meth_QGLFramebufferObjectFormat_setAttachment(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLFramebufferObject::Attachment a0;
         ::QGLFramebufferObjectFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QGLFramebufferObjectFormat, &sipCpp, sipType_QGLFramebufferObject_Attachment, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setAttachment(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFramebufferObjectFormat, sipName_setAttachment, doc_QGLFramebufferObjectFormat_setAttachment);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFramebufferObjectFormat_attachment, "attachment(self) -> QGLFramebufferObject.Attachment");

extern "C" {static PyObject *meth_QGLFramebufferObjectFormat_attachment(PyObject *, PyObject *);}
static PyObject *meth_QGLFramebufferObjectFormat_attachment(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFramebufferObjectFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLFramebufferObjectFormat, &sipCpp))
        {
             ::QGLFramebufferObject::Attachment sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->attachment();
            Py_END_ALLOW_THREADS

            return sipConvertFromEnum(static_cast<int>(sipRes), sipType_QGLFramebufferObject_Attachment);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFramebufferObjectFormat, sipName_attachment, doc_QGLFramebufferObjectFormat_attachment);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFramebufferObjectFormat_setTextureTarget, "setTextureTarget(self, int)");

extern "C" {static PyObject *meth_QGLFramebufferObjectFormat_setTextureTarget(PyObject *, PyObject *);}
static PyObject *meth_QGLFramebufferObjectFormat_setTextureTarget(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::GLenum a0;
         ::QGLFramebufferObjectFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QGLFramebufferObjectFormat, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setTextureTarget(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFramebufferObjectFormat, sipName_setTextureTarget, doc_QGLFramebufferObjectFormat_setTextureTarget);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFramebufferObjectFormat_textureTarget, "textureTarget(self) -> int");

extern "C" {static PyObject *meth_QGLFramebufferObjectFormat_textureTarget(PyObject *, PyObject *);}
static PyObject *meth_QGLFramebufferObjectFormat_textureTarget(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFramebufferObjectFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLFramebufferObjectFormat, &sipCpp))
        {
             ::GLenum sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->textureTarget();
            Py_END_ALLOW_THREADS

            return PyLong_FromUnsignedLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFramebufferObjectFormat, sipName_textureTarget, doc_QGLFramebufferObjectFormat_textureTarget);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFramebufferObjectFormat_setInternalTextureFormat, "setInternalTextureFormat(self, int)");

extern "C" {static PyObject *meth_QGLFramebufferObjectFormat_setInternalTextureFormat(PyObject *, PyObject *);}
static PyObject *meth_QGLFramebufferObjectFormat_setInternalTextureFormat(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::GLenum a0;
         ::QGLFramebufferObjectFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QGLFramebufferObjectFormat, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setInternalTextureFormat(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFramebufferObjectFormat, sipName_setInternalTextureFormat, doc_QGLFramebufferObjectFormat_setInternalTextureFormat);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFramebufferObjectFormat_internalTextureFormat, "internalTextureFormat(self) -> int");

extern "C" {static PyObject *meth_QGLFramebufferObjectFormat_internalTextureFormat(PyObject *, PyObject *);}
static PyObject *meth_QGLFramebufferObjectFormat_internalTextureFormat(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFramebufferObjectFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLFramebufferObjectFormat, &sipCpp))
        {
             ::GLenum sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->internalTextureFormat();
            Py_END_ALLOW_THREADS

            return PyLong_FromUnsignedLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFramebufferObjectFormat, sipName_internalTextureFormat, doc_QGLFramebufferObjectFormat_internalTextureFormat);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFramebufferObjectFormat_setMipmap, "setMipmap(self, bool)");

extern "C" {static PyObject *meth_QGLFramebufferObjectFormat_setMipmap(PyObject *, PyObject *);}
static PyObject *meth_QGLFramebufferObjectFormat_setMipmap(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        bool a0;
         ::QGLFramebufferObjectFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bb", &sipSelf, sipType_QGLFramebufferObjectFormat, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setMipmap(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFramebufferObjectFormat, sipName_setMipmap, doc_QGLFramebufferObjectFormat_setMipmap);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFramebufferObjectFormat_mipmap, "mipmap(self) -> bool");

extern "C" {static PyObject *meth_QGLFramebufferObjectFormat_mipmap(PyObject *, PyObject *);}
static PyObject *meth_QGLFramebufferObjectFormat_mipmap(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFramebufferObjectFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLFramebufferObjectFormat, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->mipmap();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFramebufferObjectFormat, sipName_mipmap, doc_QGLFramebufferObjectFormat_mipmap);

    return NULL;
}


extern "C" {static PyObject *slot_QGLFramebufferObjectFormat___ne__(PyObject *,PyObject *);}
static PyObject *slot_QGLFramebufferObjectFormat___ne__(PyObject *sipSelf,PyObject *sipArg)
{
     ::QGLFramebufferObjectFormat *sipCpp = reinterpret_cast< ::QGLFramebufferObjectFormat *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGLFramebufferObjectFormat));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFramebufferObjectFormat* a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J9", sipType_QGLFramebufferObjectFormat, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp-> ::QGLFramebufferObjectFormat::operator!=(*a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtOpenGL, ne_slot, sipType_QGLFramebufferObjectFormat, sipSelf, sipArg);
}


extern "C" {static PyObject *slot_QGLFramebufferObjectFormat___eq__(PyObject *,PyObject *);}
static PyObject *slot_QGLFramebufferObjectFormat___eq__(PyObject *sipSelf,PyObject *sipArg)
{
     ::QGLFramebufferObjectFormat *sipCpp = reinterpret_cast< ::QGLFramebufferObjectFormat *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGLFramebufferObjectFormat));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFramebufferObjectFormat* a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J9", sipType_QGLFramebufferObjectFormat, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp-> ::QGLFramebufferObjectFormat::operator==(*a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtOpenGL, eq_slot, sipType_QGLFramebufferObjectFormat, sipSelf, sipArg);
}


/* Call the instance's destructor. */
extern "C" {static void release_QGLFramebufferObjectFormat(void *, int);}
static void release_QGLFramebufferObjectFormat(void *sipCppV, int)
{
    Py_BEGIN_ALLOW_THREADS

    delete reinterpret_cast< ::QGLFramebufferObjectFormat *>(sipCppV);

    Py_END_ALLOW_THREADS
}


extern "C" {static void assign_QGLFramebufferObjectFormat(void *, SIP_SSIZE_T, void *);}
static void assign_QGLFramebufferObjectFormat(void *sipDst, SIP_SSIZE_T sipDstIdx, void *sipSrc)
{
    reinterpret_cast< ::QGLFramebufferObjectFormat *>(sipDst)[sipDstIdx] = *reinterpret_cast< ::QGLFramebufferObjectFormat *>(sipSrc);
}


extern "C" {static void *array_QGLFramebufferObjectFormat(SIP_SSIZE_T);}
static void *array_QGLFramebufferObjectFormat(SIP_SSIZE_T sipNrElem)
{
    return new  ::QGLFramebufferObjectFormat[sipNrElem];
}


extern "C" {static void *copy_QGLFramebufferObjectFormat(const void *, SIP_SSIZE_T);}
static void *copy_QGLFramebufferObjectFormat(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new  ::QGLFramebufferObjectFormat(reinterpret_cast<const  ::QGLFramebufferObjectFormat *>(sipSrc)[sipSrcIdx]);
}


extern "C" {static void dealloc_QGLFramebufferObjectFormat(sipSimpleWrapper *);}
static void dealloc_QGLFramebufferObjectFormat(sipSimpleWrapper *sipSelf)
{
    if (sipIsOwnedByPython(sipSelf))
    {
        release_QGLFramebufferObjectFormat(sipGetAddress(sipSelf), 0);
    }
}


extern "C" {static void *init_type_QGLFramebufferObjectFormat(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QGLFramebufferObjectFormat(sipSimpleWrapper *, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
     ::QGLFramebufferObjectFormat *sipCpp = 0;

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new  ::QGLFramebufferObjectFormat();
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    {
        const  ::QGLFramebufferObjectFormat* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QGLFramebufferObjectFormat, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new  ::QGLFramebufferObjectFormat(*a0);
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's Python slots. */
static sipPySlotDef slots_QGLFramebufferObjectFormat[] = {
    {(void *)slot_QGLFramebufferObjectFormat___ne__, ne_slot},
    {(void *)slot_QGLFramebufferObjectFormat___eq__, eq_slot},
    {0, (sipPySlotType)0}
};


static PyMethodDef methods_QGLFramebufferObjectFormat[] = {
    {SIP_MLNAME_CAST(sipName_attachment), meth_QGLFramebufferObjectFormat_attachment, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFramebufferObjectFormat_attachment)},
    {SIP_MLNAME_CAST(sipName_internalTextureFormat), meth_QGLFramebufferObjectFormat_internalTextureFormat, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFramebufferObjectFormat_internalTextureFormat)},
    {SIP_MLNAME_CAST(sipName_mipmap), meth_QGLFramebufferObjectFormat_mipmap, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFramebufferObjectFormat_mipmap)},
    {SIP_MLNAME_CAST(sipName_samples), meth_QGLFramebufferObjectFormat_samples, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFramebufferObjectFormat_samples)},
    {SIP_MLNAME_CAST(sipName_setAttachment), meth_QGLFramebufferObjectFormat_setAttachment, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFramebufferObjectFormat_setAttachment)},
    {SIP_MLNAME_CAST(sipName_setInternalTextureFormat), meth_QGLFramebufferObjectFormat_setInternalTextureFormat, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFramebufferObjectFormat_setInternalTextureFormat)},
    {SIP_MLNAME_CAST(sipName_setMipmap), meth_QGLFramebufferObjectFormat_setMipmap, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFramebufferObjectFormat_setMipmap)},
    {SIP_MLNAME_CAST(sipName_setSamples), meth_QGLFramebufferObjectFormat_setSamples, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFramebufferObjectFormat_setSamples)},
    {SIP_MLNAME_CAST(sipName_setTextureTarget), meth_QGLFramebufferObjectFormat_setTextureTarget, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFramebufferObjectFormat_setTextureTarget)},
    {SIP_MLNAME_CAST(sipName_textureTarget), meth_QGLFramebufferObjectFormat_textureTarget, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFramebufferObjectFormat_textureTarget)}
};

PyDoc_STRVAR(doc_QGLFramebufferObjectFormat, "\1QGLFramebufferObjectFormat()\n"
"QGLFramebufferObjectFormat(QGLFramebufferObjectFormat)");


static pyqt4ClassPluginDef plugin_QGLFramebufferObjectFormat = {
    0,
    0,
    0
};


sipClassTypeDef sipTypeDef_QtOpenGL_QGLFramebufferObjectFormat = {
    {
        -1,
        0,
        0,
        SIP_TYPE_CLASS,
        sipNameNr_QGLFramebufferObjectFormat,
        {0},
        &plugin_QGLFramebufferObjectFormat
    },
    {
        sipNameNr_QGLFramebufferObjectFormat,
        {0, 0, 1},
        10, methods_QGLFramebufferObjectFormat,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QGLFramebufferObjectFormat,
    sipNameNr_PyQt4_QtCore_pyqtWrapperType,
    sipNameNr_sip_simplewrapper,
    0,
    slots_QGLFramebufferObjectFormat,
    init_type_QGLFramebufferObjectFormat,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QGLFramebufferObjectFormat,
    assign_QGLFramebufferObjectFormat,
    array_QGLFramebufferObjectFormat,
    copy_QGLFramebufferObjectFormat,
    release_QGLFramebufferObjectFormat,
    0,
    0,
    0,
    0,
    0,
    0,
    0
};

#line 29 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qglframebufferobject.sip"
#include <qglframebufferobject.h>
#line 8083 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qsize.sip"
#include <qsize.h>
#line 8087 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 117 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qglframebufferobject.sip"
#include <qglframebufferobject.h>
#line 8090 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qrect.sip"
#include <qrect.h>
#line 8093 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qpaintdevice.sip"
#include <qpaintdevice.h>
#line 8096 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 52 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qpaintengine.sip"
#include <qpaintengine.h>
#line 8099 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qimage.sip"
#include <qimage.h>
#line 8102 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 159 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qrect.sip"
#include <qrect.h>
#line 8105 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 110 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qpoint.sip"
#include <qpoint.h>
#line 8108 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"


class sipQGLFramebufferObject : public  ::QGLFramebufferObject
{
public:
    sipQGLFramebufferObject(const  ::QSize&, ::GLenum);
    sipQGLFramebufferObject(int,int, ::GLenum);
    sipQGLFramebufferObject(const  ::QSize&, ::QGLFramebufferObject::Attachment, ::GLenum, ::GLenum);
    sipQGLFramebufferObject(int,int, ::QGLFramebufferObject::Attachment, ::GLenum, ::GLenum);
    sipQGLFramebufferObject(const  ::QSize&,const  ::QGLFramebufferObjectFormat&);
    sipQGLFramebufferObject(int,int,const  ::QGLFramebufferObjectFormat&);
    virtual ~sipQGLFramebufferObject();

    /*
     * There is a public method for every protected method visible from
     * this class.
     */
    int sipProtectVirt_metric(bool, ::QPaintDevice::PaintDeviceMetric) const;

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
     ::QPaintEngine* paintEngine() const;
    int metric( ::QPaintDevice::PaintDeviceMetric) const;

public:
    sipSimpleWrapper *sipPySelf;

private:
    sipQGLFramebufferObject(const sipQGLFramebufferObject &);
    sipQGLFramebufferObject &operator = (const sipQGLFramebufferObject &);

    char sipPyMethods[2];
};

sipQGLFramebufferObject::sipQGLFramebufferObject(const  ::QSize& a0, ::GLenum a1):  ::QGLFramebufferObject(a0,a1), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQGLFramebufferObject::sipQGLFramebufferObject(int a0,int a1, ::GLenum a2):  ::QGLFramebufferObject(a0,a1,a2), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQGLFramebufferObject::sipQGLFramebufferObject(const  ::QSize& a0, ::QGLFramebufferObject::Attachment a1, ::GLenum a2, ::GLenum a3):  ::QGLFramebufferObject(a0,a1,a2,a3), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQGLFramebufferObject::sipQGLFramebufferObject(int a0,int a1, ::QGLFramebufferObject::Attachment a2, ::GLenum a3, ::GLenum a4):  ::QGLFramebufferObject(a0,a1,a2,a3,a4), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQGLFramebufferObject::sipQGLFramebufferObject(const  ::QSize& a0,const  ::QGLFramebufferObjectFormat& a1):  ::QGLFramebufferObject(a0,a1), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQGLFramebufferObject::sipQGLFramebufferObject(int a0,int a1,const  ::QGLFramebufferObjectFormat& a2):  ::QGLFramebufferObject(a0,a1,a2), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQGLFramebufferObject::~sipQGLFramebufferObject()
{
    sipInstanceDestroyedEx(&sipPySelf);
}

 ::QPaintEngine* sipQGLFramebufferObject::paintEngine() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[0]),sipPySelf,NULL,sipName_paintEngine);

    if (!sipMeth)
        return  ::QGLFramebufferObject::paintEngine();

    extern  ::QPaintEngine* sipVH_QtOpenGL_30(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH_QtOpenGL_30(sipGILState, 0, sipPySelf, sipMeth);
}

int sipQGLFramebufferObject::metric( ::QPaintDevice::PaintDeviceMetric a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[1]),sipPySelf,NULL,sipName_metric);

    if (!sipMeth)
        return  ::QGLFramebufferObject::metric(a0);

    extern int sipVH_QtOpenGL_31(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QPaintDevice::PaintDeviceMetric);

    return sipVH_QtOpenGL_31(sipGILState, 0, sipPySelf, sipMeth, a0);
}

int sipQGLFramebufferObject::sipProtectVirt_metric(bool sipSelfWasArg, ::QPaintDevice::PaintDeviceMetric a0) const
{
    return (sipSelfWasArg ?  ::QGLFramebufferObject::metric(a0) : metric(a0));
}


PyDoc_STRVAR(doc_QGLFramebufferObject_attachment, "attachment(self) -> QGLFramebufferObject.Attachment");

extern "C" {static PyObject *meth_QGLFramebufferObject_attachment(PyObject *, PyObject *);}
static PyObject *meth_QGLFramebufferObject_attachment(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFramebufferObject *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLFramebufferObject, &sipCpp))
        {
             ::QGLFramebufferObject::Attachment sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->attachment();
            Py_END_ALLOW_THREADS

            return sipConvertFromEnum(static_cast<int>(sipRes), sipType_QGLFramebufferObject_Attachment);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFramebufferObject, sipName_attachment, doc_QGLFramebufferObject_attachment);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFramebufferObject_isValid, "isValid(self) -> bool");

extern "C" {static PyObject *meth_QGLFramebufferObject_isValid(PyObject *, PyObject *);}
static PyObject *meth_QGLFramebufferObject_isValid(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFramebufferObject *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLFramebufferObject, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isValid();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFramebufferObject, sipName_isValid, doc_QGLFramebufferObject_isValid);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFramebufferObject_bind, "bind(self) -> bool");

extern "C" {static PyObject *meth_QGLFramebufferObject_bind(PyObject *, PyObject *);}
static PyObject *meth_QGLFramebufferObject_bind(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLFramebufferObject *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLFramebufferObject, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->bind();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFramebufferObject, sipName_bind, doc_QGLFramebufferObject_bind);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFramebufferObject_isBound, "isBound(self) -> bool");

extern "C" {static PyObject *meth_QGLFramebufferObject_isBound(PyObject *, PyObject *);}
static PyObject *meth_QGLFramebufferObject_isBound(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFramebufferObject *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLFramebufferObject, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isBound();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFramebufferObject, sipName_isBound, doc_QGLFramebufferObject_isBound);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFramebufferObject_release, "release(self) -> bool");

extern "C" {static PyObject *meth_QGLFramebufferObject_release(PyObject *, PyObject *);}
static PyObject *meth_QGLFramebufferObject_release(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLFramebufferObject *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLFramebufferObject, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->release();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFramebufferObject, sipName_release, doc_QGLFramebufferObject_release);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFramebufferObject_texture, "texture(self) -> int");

extern "C" {static PyObject *meth_QGLFramebufferObject_texture(PyObject *, PyObject *);}
static PyObject *meth_QGLFramebufferObject_texture(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFramebufferObject *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLFramebufferObject, &sipCpp))
        {
             ::GLuint sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->texture();
            Py_END_ALLOW_THREADS

            return PyLong_FromUnsignedLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFramebufferObject, sipName_texture, doc_QGLFramebufferObject_texture);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFramebufferObject_drawTexture, "drawTexture(self, QRectF, int, textureTarget: int = GL_TEXTURE_2D)\n"
"drawTexture(self, Union[QPointF, QPoint], int, textureTarget: int = GL_TEXTURE_2D)");

extern "C" {static PyObject *meth_QGLFramebufferObject_drawTexture(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLFramebufferObject_drawTexture(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QRectF* a0;
         ::GLuint a1;
         ::GLenum a2 = GL_TEXTURE_2D;
         ::QGLFramebufferObject *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_textureTarget,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ9u|u", &sipSelf, sipType_QGLFramebufferObject, &sipCpp, sipType_QRectF, &a0, &a1, &a2))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->drawTexture(*a0,a1,a2);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const  ::QPointF* a0;
        int a0State = 0;
         ::GLuint a1;
         ::GLenum a2 = GL_TEXTURE_2D;
         ::QGLFramebufferObject *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_textureTarget,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ1u|u", &sipSelf, sipType_QGLFramebufferObject, &sipCpp, sipType_QPointF, &a0, &a0State, &a1, &a2))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->drawTexture(*a0,a1,a2);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::QPointF *>(a0),sipType_QPointF,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFramebufferObject, sipName_drawTexture, doc_QGLFramebufferObject_drawTexture);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFramebufferObject_size, "size(self) -> QSize");

extern "C" {static PyObject *meth_QGLFramebufferObject_size(PyObject *, PyObject *);}
static PyObject *meth_QGLFramebufferObject_size(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFramebufferObject *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLFramebufferObject, &sipCpp))
        {
             ::QSize*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QSize(sipCpp->size());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QSize,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFramebufferObject, sipName_size, doc_QGLFramebufferObject_size);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFramebufferObject_toImage, "toImage(self) -> QImage");

extern "C" {static PyObject *meth_QGLFramebufferObject_toImage(PyObject *, PyObject *);}
static PyObject *meth_QGLFramebufferObject_toImage(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFramebufferObject *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLFramebufferObject, &sipCpp))
        {
             ::QImage*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QImage(sipCpp->toImage());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QImage,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFramebufferObject, sipName_toImage, doc_QGLFramebufferObject_toImage);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFramebufferObject_paintEngine, "paintEngine(self) -> QPaintEngine");

extern "C" {static PyObject *meth_QGLFramebufferObject_paintEngine(PyObject *, PyObject *);}
static PyObject *meth_QGLFramebufferObject_paintEngine(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        const  ::QGLFramebufferObject *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLFramebufferObject, &sipCpp))
        {
             ::QPaintEngine*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp-> ::QGLFramebufferObject::paintEngine() : sipCpp->paintEngine());
            Py_END_ALLOW_THREADS

            return sipConvertFromType(sipRes,sipType_QPaintEngine,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFramebufferObject, sipName_paintEngine, doc_QGLFramebufferObject_paintEngine);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFramebufferObject_handle, "handle(self) -> int");

extern "C" {static PyObject *meth_QGLFramebufferObject_handle(PyObject *, PyObject *);}
static PyObject *meth_QGLFramebufferObject_handle(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFramebufferObject *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLFramebufferObject, &sipCpp))
        {
             ::GLuint sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->handle();
            Py_END_ALLOW_THREADS

            return PyLong_FromUnsignedLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFramebufferObject, sipName_handle, doc_QGLFramebufferObject_handle);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFramebufferObject_hasOpenGLFramebufferObjects, "hasOpenGLFramebufferObjects() -> bool");

extern "C" {static PyObject *meth_QGLFramebufferObject_hasOpenGLFramebufferObjects(PyObject *, PyObject *);}
static PyObject *meth_QGLFramebufferObject_hasOpenGLFramebufferObjects(PyObject *, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        if (sipParseArgs(&sipParseErr, sipArgs, ""))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes =  ::QGLFramebufferObject::hasOpenGLFramebufferObjects();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFramebufferObject, sipName_hasOpenGLFramebufferObjects, doc_QGLFramebufferObject_hasOpenGLFramebufferObjects);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFramebufferObject_metric, "metric(self, QPaintDevice.PaintDeviceMetric) -> int");

extern "C" {static PyObject *meth_QGLFramebufferObject_metric(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLFramebufferObject_metric(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QPaintDevice::PaintDeviceMetric a0;
        const sipQGLFramebufferObject *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BE", &sipSelf, sipType_QGLFramebufferObject, &sipCpp, sipType_QPaintDevice_PaintDeviceMetric, &a0))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtectVirt_metric(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFramebufferObject, sipName_metric, doc_QGLFramebufferObject_metric);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFramebufferObject_format, "format(self) -> QGLFramebufferObjectFormat");

extern "C" {static PyObject *meth_QGLFramebufferObject_format(PyObject *, PyObject *);}
static PyObject *meth_QGLFramebufferObject_format(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFramebufferObject *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLFramebufferObject, &sipCpp))
        {
             ::QGLFramebufferObjectFormat*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QGLFramebufferObjectFormat(sipCpp->format());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QGLFramebufferObjectFormat,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFramebufferObject, sipName_format, doc_QGLFramebufferObject_format);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFramebufferObject_hasOpenGLFramebufferBlit, "hasOpenGLFramebufferBlit() -> bool");

extern "C" {static PyObject *meth_QGLFramebufferObject_hasOpenGLFramebufferBlit(PyObject *, PyObject *);}
static PyObject *meth_QGLFramebufferObject_hasOpenGLFramebufferBlit(PyObject *, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        if (sipParseArgs(&sipParseErr, sipArgs, ""))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes =  ::QGLFramebufferObject::hasOpenGLFramebufferBlit();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFramebufferObject, sipName_hasOpenGLFramebufferBlit, doc_QGLFramebufferObject_hasOpenGLFramebufferBlit);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFramebufferObject_blitFramebuffer, "blitFramebuffer(QGLFramebufferObject, QRect, QGLFramebufferObject, QRect, buffers: int = GL_COLOR_BUFFER_BIT, filter: int = GL_NEAREST)");

extern "C" {static PyObject *meth_QGLFramebufferObject_blitFramebuffer(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLFramebufferObject_blitFramebuffer(PyObject *, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLFramebufferObject* a0;
        const  ::QRect* a1;
         ::QGLFramebufferObject* a2;
        const  ::QRect* a3;
         ::GLbitfield a4 = GL_COLOR_BUFFER_BIT;
         ::GLenum a5 = GL_NEAREST;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            NULL,
            NULL,
            sipName_buffers,
            sipName_filter,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "J8J9J8J9|uu", sipType_QGLFramebufferObject, &a0, sipType_QRect, &a1, sipType_QGLFramebufferObject, &a2, sipType_QRect, &a3, &a4, &a5))
        {
            Py_BEGIN_ALLOW_THREADS
             ::QGLFramebufferObject::blitFramebuffer(a0,*a1,a2,*a3,a4,a5);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFramebufferObject, sipName_blitFramebuffer, doc_QGLFramebufferObject_blitFramebuffer);

    return NULL;
}


/* Cast a pointer to a type somewhere in its inheritance hierarchy. */
extern "C" {static void *cast_QGLFramebufferObject(void *, const sipTypeDef *);}
static void *cast_QGLFramebufferObject(void *sipCppV, const sipTypeDef *targetType)
{
     ::QGLFramebufferObject *sipCpp = reinterpret_cast< ::QGLFramebufferObject *>(sipCppV);

    if (targetType == sipType_QPaintDevice)
        return static_cast< ::QPaintDevice *>(sipCpp);

    return sipCppV;
}


/* Call the instance's destructor. */
extern "C" {static void release_QGLFramebufferObject(void *, int);}
static void release_QGLFramebufferObject(void *sipCppV, int sipState)
{
    Py_BEGIN_ALLOW_THREADS

    if (sipState & SIP_DERIVED_CLASS)
        delete reinterpret_cast<sipQGLFramebufferObject *>(sipCppV);
    else
        delete reinterpret_cast< ::QGLFramebufferObject *>(sipCppV);

    Py_END_ALLOW_THREADS
}


extern "C" {static void dealloc_QGLFramebufferObject(sipSimpleWrapper *);}
static void dealloc_QGLFramebufferObject(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerivedClass(sipSelf))
        reinterpret_cast<sipQGLFramebufferObject *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsOwnedByPython(sipSelf))
    {
        release_QGLFramebufferObject(sipGetAddress(sipSelf), sipIsDerivedClass(sipSelf));
    }
}


extern "C" {static void *init_type_QGLFramebufferObject(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QGLFramebufferObject(sipSimpleWrapper *sipSelf, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
    sipQGLFramebufferObject *sipCpp = 0;

    {
        const  ::QSize* a0;
         ::GLenum a1 = GL_TEXTURE_2D;

        static const char *sipKwdList[] = {
            NULL,
            sipName_target,
        };

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "J9|u", sipType_QSize, &a0, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQGLFramebufferObject(*a0,a1);
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    {
        int a0;
        int a1;
         ::GLenum a2 = GL_TEXTURE_2D;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_target,
        };

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "ii|u", &a0, &a1, &a2))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQGLFramebufferObject(a0,a1,a2);
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    {
        const  ::QSize* a0;
         ::QGLFramebufferObject::Attachment a1;
         ::GLenum a2 = GL_TEXTURE_2D;
         ::GLenum a3 = GL_RGBA8;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_target,
            sipName_internalFormat,
        };

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "J9E|uu", sipType_QSize, &a0, sipType_QGLFramebufferObject_Attachment, &a1, &a2, &a3))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQGLFramebufferObject(*a0,a1,a2,a3);
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    {
        int a0;
        int a1;
         ::QGLFramebufferObject::Attachment a2;
         ::GLenum a3 = GL_TEXTURE_2D;
         ::GLenum a4 = GL_RGBA8;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            NULL,
            sipName_target,
            sipName_internalFormat,
        };

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "iiE|uu", &a0, &a1, sipType_QGLFramebufferObject_Attachment, &a2, &a3, &a4))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQGLFramebufferObject(a0,a1,a2,a3,a4);
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    {
        const  ::QSize* a0;
        const  ::QGLFramebufferObjectFormat* a1;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9J9", sipType_QSize, &a0, sipType_QGLFramebufferObjectFormat, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQGLFramebufferObject(*a0,*a1);
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    {
        int a0;
        int a1;
        const  ::QGLFramebufferObjectFormat* a2;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "iiJ9", &a0, &a1, sipType_QGLFramebufferObjectFormat, &a2))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQGLFramebufferObject(a0,a1,*a2);
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's super-types. */
static sipEncodedTypeDef supers_QGLFramebufferObject[] = {{25, 1, 1}};


static PyMethodDef methods_QGLFramebufferObject[] = {
    {SIP_MLNAME_CAST(sipName_attachment), meth_QGLFramebufferObject_attachment, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFramebufferObject_attachment)},
    {SIP_MLNAME_CAST(sipName_bind), meth_QGLFramebufferObject_bind, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFramebufferObject_bind)},
    {SIP_MLNAME_CAST(sipName_blitFramebuffer), (PyCFunction)meth_QGLFramebufferObject_blitFramebuffer, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLFramebufferObject_blitFramebuffer)},
    {SIP_MLNAME_CAST(sipName_drawTexture), (PyCFunction)meth_QGLFramebufferObject_drawTexture, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLFramebufferObject_drawTexture)},
    {SIP_MLNAME_CAST(sipName_format), meth_QGLFramebufferObject_format, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFramebufferObject_format)},
    {SIP_MLNAME_CAST(sipName_handle), meth_QGLFramebufferObject_handle, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFramebufferObject_handle)},
    {SIP_MLNAME_CAST(sipName_hasOpenGLFramebufferBlit), meth_QGLFramebufferObject_hasOpenGLFramebufferBlit, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFramebufferObject_hasOpenGLFramebufferBlit)},
    {SIP_MLNAME_CAST(sipName_hasOpenGLFramebufferObjects), meth_QGLFramebufferObject_hasOpenGLFramebufferObjects, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFramebufferObject_hasOpenGLFramebufferObjects)},
    {SIP_MLNAME_CAST(sipName_isBound), meth_QGLFramebufferObject_isBound, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFramebufferObject_isBound)},
    {SIP_MLNAME_CAST(sipName_isValid), meth_QGLFramebufferObject_isValid, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFramebufferObject_isValid)},
    {SIP_MLNAME_CAST(sipName_metric), (PyCFunction)meth_QGLFramebufferObject_metric, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLFramebufferObject_metric)},
    {SIP_MLNAME_CAST(sipName_paintEngine), meth_QGLFramebufferObject_paintEngine, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFramebufferObject_paintEngine)},
    {SIP_MLNAME_CAST(sipName_release), meth_QGLFramebufferObject_release, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFramebufferObject_release)},
    {SIP_MLNAME_CAST(sipName_size), meth_QGLFramebufferObject_size, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFramebufferObject_size)},
    {SIP_MLNAME_CAST(sipName_texture), meth_QGLFramebufferObject_texture, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFramebufferObject_texture)},
    {SIP_MLNAME_CAST(sipName_toImage), meth_QGLFramebufferObject_toImage, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFramebufferObject_toImage)}
};

static sipEnumMemberDef enummembers_QGLFramebufferObject[] = {
    {sipName_CombinedDepthStencil, static_cast<int>( ::QGLFramebufferObject::CombinedDepthStencil), 16},
    {sipName_Depth, static_cast<int>( ::QGLFramebufferObject::Depth), 16},
    {sipName_NoAttachment, static_cast<int>( ::QGLFramebufferObject::NoAttachment), 16},
};

PyDoc_STRVAR(doc_QGLFramebufferObject, "\1QGLFramebufferObject(QSize, target: int = GL_TEXTURE_2D)\n"
"QGLFramebufferObject(int, int, target: int = GL_TEXTURE_2D)\n"
"QGLFramebufferObject(QSize, QGLFramebufferObject.Attachment, target: int = GL_TEXTURE_2D, internalFormat: int = GL_RGBA8)\n"
"QGLFramebufferObject(int, int, QGLFramebufferObject.Attachment, target: int = GL_TEXTURE_2D, internalFormat: int = GL_RGBA8)\n"
"QGLFramebufferObject(QSize, QGLFramebufferObjectFormat)\n"
"QGLFramebufferObject(int, int, QGLFramebufferObjectFormat)");


static pyqt4ClassPluginDef plugin_QGLFramebufferObject = {
    0,
    0,
    0
};


sipClassTypeDef sipTypeDef_QtOpenGL_QGLFramebufferObject = {
    {
        -1,
        0,
        0,
        SIP_TYPE_CLASS,
        sipNameNr_QGLFramebufferObject,
        {0},
        &plugin_QGLFramebufferObject
    },
    {
        sipNameNr_QGLFramebufferObject,
        {0, 0, 1},
        16, methods_QGLFramebufferObject,
        3, enummembers_QGLFramebufferObject,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QGLFramebufferObject,
    -1,
    -1,
    supers_QGLFramebufferObject,
    0,
    init_type_QGLFramebufferObject,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QGLFramebufferObject,
    0,
    0,
    0,
    release_QGLFramebufferObject,
    cast_QGLFramebufferObject,
    0,
    0,
    0,
    0,
    0,
    0
};

#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qglcolormap.sip"
#include <qglcolormap.h>
#line 9024 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qcolor.sip"
#include <qcolor.h>
#line 9028 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"


class sipQGLColormap : public  ::QGLColormap
{
public:
    sipQGLColormap();
    sipQGLColormap(const  ::QGLColormap&);
    ~sipQGLColormap();

    /*
     * There is a public method for every protected method visible from
     * this class.
     */
     ::Qt::HANDLE sipProtect_handle();
    void sipProtect_setHandle( ::Qt::HANDLE);

public:
    sipSimpleWrapper *sipPySelf;

private:
    sipQGLColormap(const sipQGLColormap &);
    sipQGLColormap &operator = (const sipQGLColormap &);
};

sipQGLColormap::sipQGLColormap():  ::QGLColormap(), sipPySelf(0)
{
}

sipQGLColormap::sipQGLColormap(const  ::QGLColormap& a0):  ::QGLColormap(a0), sipPySelf(0)
{
}

sipQGLColormap::~sipQGLColormap()
{
    sipInstanceDestroyedEx(&sipPySelf);
}

 ::Qt::HANDLE sipQGLColormap::sipProtect_handle()
{
    return  ::QGLColormap::handle();
}

void sipQGLColormap::sipProtect_setHandle( ::Qt::HANDLE a0)
{
     ::QGLColormap::setHandle(a0);
}


PyDoc_STRVAR(doc_QGLColormap_detach, "detach(self)");

extern "C" {static PyObject *meth_QGLColormap_detach(PyObject *, PyObject *);}
static PyObject *meth_QGLColormap_detach(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLColormap *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLColormap, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->detach();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLColormap, sipName_detach, doc_QGLColormap_detach);

    return NULL;
}


PyDoc_STRVAR(doc_QGLColormap_isEmpty, "isEmpty(self) -> bool");

extern "C" {static PyObject *meth_QGLColormap_isEmpty(PyObject *, PyObject *);}
static PyObject *meth_QGLColormap_isEmpty(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLColormap *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLColormap, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isEmpty();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLColormap, sipName_isEmpty, doc_QGLColormap_isEmpty);

    return NULL;
}


PyDoc_STRVAR(doc_QGLColormap_size, "size(self) -> int");

extern "C" {static PyObject *meth_QGLColormap_size(PyObject *, PyObject *);}
static PyObject *meth_QGLColormap_size(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLColormap *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLColormap, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->size();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLColormap, sipName_size, doc_QGLColormap_size);

    return NULL;
}


PyDoc_STRVAR(doc_QGLColormap_setEntries, "setEntries(self, List[int], base: int = 0)");

extern "C" {static PyObject *meth_QGLColormap_setEntries(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLColormap_setEntries(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        PyObject * a0;
        int a1 = 0;
         ::QGLColormap *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            sipName_base,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BT|i", &sipSelf, sipType_QGLColormap, &sipCpp, &PyList_Type, &a0, &a1))
        {
#line 40 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qglcolormap.sip"
        // The Python implementation takes a list of numbers.
        QRgb *colours = new QRgb[PyList_GET_SIZE(a0)];
        
        for (SIP_SSIZE_T i = 0; i < PyList_GET_SIZE(a0); ++i)
            colours[i] = PyLong_AsUnsignedLong(PyList_GET_ITEM(a0, i));
        
        sipCpp->setEntries(PyList_GET_SIZE(a0), colours, a1);
        
        delete[] colours;
#line 9196 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLColormap, sipName_setEntries, doc_QGLColormap_setEntries);

    return NULL;
}


PyDoc_STRVAR(doc_QGLColormap_setEntry, "setEntry(self, int, int)\n"
"setEntry(self, int, Union[QColor, Qt.GlobalColor])");

extern "C" {static PyObject *meth_QGLColormap_setEntry(PyObject *, PyObject *);}
static PyObject *meth_QGLColormap_setEntry(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
         ::QRgb a1;
         ::QGLColormap *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Biu", &sipSelf, sipType_QGLColormap, &sipCpp, &a0, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setEntry(a0,a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
        const  ::QColor* a1;
        int a1State = 0;
         ::QGLColormap *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BiJ1", &sipSelf, sipType_QGLColormap, &sipCpp, &a0, sipType_QColor, &a1, &a1State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setEntry(a0,*a1);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::QColor *>(a1),sipType_QColor,a1State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLColormap, sipName_setEntry, doc_QGLColormap_setEntry);

    return NULL;
}


PyDoc_STRVAR(doc_QGLColormap_entryRgb, "entryRgb(self, int) -> int");

extern "C" {static PyObject *meth_QGLColormap_entryRgb(PyObject *, PyObject *);}
static PyObject *meth_QGLColormap_entryRgb(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        const  ::QGLColormap *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QGLColormap, &sipCpp, &a0))
        {
             ::QRgb sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->entryRgb(a0);
            Py_END_ALLOW_THREADS

            return PyLong_FromUnsignedLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLColormap, sipName_entryRgb, doc_QGLColormap_entryRgb);

    return NULL;
}


PyDoc_STRVAR(doc_QGLColormap_entryColor, "entryColor(self, int) -> QColor");

extern "C" {static PyObject *meth_QGLColormap_entryColor(PyObject *, PyObject *);}
static PyObject *meth_QGLColormap_entryColor(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        const  ::QGLColormap *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QGLColormap, &sipCpp, &a0))
        {
             ::QColor*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QColor(sipCpp->entryColor(a0));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QColor,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLColormap, sipName_entryColor, doc_QGLColormap_entryColor);

    return NULL;
}


PyDoc_STRVAR(doc_QGLColormap_find, "find(self, int) -> int");

extern "C" {static PyObject *meth_QGLColormap_find(PyObject *, PyObject *);}
static PyObject *meth_QGLColormap_find(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::QRgb a0;
        const  ::QGLColormap *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QGLColormap, &sipCpp, &a0))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->find(a0);
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLColormap, sipName_find, doc_QGLColormap_find);

    return NULL;
}


PyDoc_STRVAR(doc_QGLColormap_findNearest, "findNearest(self, int) -> int");

extern "C" {static PyObject *meth_QGLColormap_findNearest(PyObject *, PyObject *);}
static PyObject *meth_QGLColormap_findNearest(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::QRgb a0;
        const  ::QGLColormap *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QGLColormap, &sipCpp, &a0))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->findNearest(a0);
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLColormap, sipName_findNearest, doc_QGLColormap_findNearest);

    return NULL;
}


PyDoc_STRVAR(doc_QGLColormap_handle, "handle(self) -> int");

extern "C" {static PyObject *meth_QGLColormap_handle(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLColormap_handle(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipQGLColormap *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QGLColormap, &sipCpp))
        {
             ::Qt::HANDLE sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_handle();
            Py_END_ALLOW_THREADS

            return PyLong_FromUnsignedLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLColormap, sipName_handle, doc_QGLColormap_handle);

    return NULL;
}


PyDoc_STRVAR(doc_QGLColormap_setHandle, "setHandle(self, int)");

extern "C" {static PyObject *meth_QGLColormap_setHandle(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLColormap_setHandle(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
         ::Qt::HANDLE a0;
        sipQGLColormap *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "Bm", &sipSelf, sipType_QGLColormap, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_setHandle(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLColormap, sipName_setHandle, doc_QGLColormap_setHandle);

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QGLColormap(void *, int);}
static void release_QGLColormap(void *sipCppV, int sipState)
{
    Py_BEGIN_ALLOW_THREADS

    if (sipState & SIP_DERIVED_CLASS)
        delete reinterpret_cast<sipQGLColormap *>(sipCppV);
    else
        delete reinterpret_cast< ::QGLColormap *>(sipCppV);

    Py_END_ALLOW_THREADS
}


extern "C" {static void assign_QGLColormap(void *, SIP_SSIZE_T, void *);}
static void assign_QGLColormap(void *sipDst, SIP_SSIZE_T sipDstIdx, void *sipSrc)
{
    reinterpret_cast< ::QGLColormap *>(sipDst)[sipDstIdx] = *reinterpret_cast< ::QGLColormap *>(sipSrc);
}


extern "C" {static void *array_QGLColormap(SIP_SSIZE_T);}
static void *array_QGLColormap(SIP_SSIZE_T sipNrElem)
{
    return new  ::QGLColormap[sipNrElem];
}


extern "C" {static void *copy_QGLColormap(const void *, SIP_SSIZE_T);}
static void *copy_QGLColormap(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new  ::QGLColormap(reinterpret_cast<const  ::QGLColormap *>(sipSrc)[sipSrcIdx]);
}


extern "C" {static void dealloc_QGLColormap(sipSimpleWrapper *);}
static void dealloc_QGLColormap(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerivedClass(sipSelf))
        reinterpret_cast<sipQGLColormap *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsOwnedByPython(sipSelf))
    {
        release_QGLColormap(sipGetAddress(sipSelf), sipIsDerivedClass(sipSelf));
    }
}


extern "C" {static void *init_type_QGLColormap(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QGLColormap(sipSimpleWrapper *sipSelf, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
    sipQGLColormap *sipCpp = 0;

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQGLColormap();
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    {
        const  ::QGLColormap* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QGLColormap, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQGLColormap(*a0);
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


static PyMethodDef methods_QGLColormap[] = {
    {SIP_MLNAME_CAST(sipName_detach), meth_QGLColormap_detach, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLColormap_detach)},
    {SIP_MLNAME_CAST(sipName_entryColor), meth_QGLColormap_entryColor, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLColormap_entryColor)},
    {SIP_MLNAME_CAST(sipName_entryRgb), meth_QGLColormap_entryRgb, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLColormap_entryRgb)},
    {SIP_MLNAME_CAST(sipName_find), meth_QGLColormap_find, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLColormap_find)},
    {SIP_MLNAME_CAST(sipName_findNearest), meth_QGLColormap_findNearest, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLColormap_findNearest)},
    {SIP_MLNAME_CAST(sipName_handle), (PyCFunction)meth_QGLColormap_handle, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLColormap_handle)},
    {SIP_MLNAME_CAST(sipName_isEmpty), meth_QGLColormap_isEmpty, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLColormap_isEmpty)},
    {SIP_MLNAME_CAST(sipName_setEntries), (PyCFunction)meth_QGLColormap_setEntries, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLColormap_setEntries)},
    {SIP_MLNAME_CAST(sipName_setEntry), meth_QGLColormap_setEntry, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLColormap_setEntry)},
    {SIP_MLNAME_CAST(sipName_setHandle), (PyCFunction)meth_QGLColormap_setHandle, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLColormap_setHandle)},
    {SIP_MLNAME_CAST(sipName_size), meth_QGLColormap_size, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLColormap_size)}
};

PyDoc_STRVAR(doc_QGLColormap, "\1QGLColormap()\n"
"QGLColormap(QGLColormap)");


static pyqt4ClassPluginDef plugin_QGLColormap = {
    0,
    0,
    0
};


sipClassTypeDef sipTypeDef_QtOpenGL_QGLColormap = {
    {
        -1,
        0,
        0,
        SIP_TYPE_CLASS,
        sipNameNr_QGLColormap,
        {0},
        &plugin_QGLColormap
    },
    {
        sipNameNr_QGLColormap,
        {0, 0, 1},
        11, methods_QGLColormap,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QGLColormap,
    sipNameNr_PyQt4_QtCore_pyqtWrapperType,
    sipNameNr_sip_simplewrapper,
    0,
    0,
    init_type_QGLColormap,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QGLColormap,
    assign_QGLColormap,
    array_QGLColormap,
    copy_QGLColormap,
    release_QGLColormap,
    0,
    0,
    0,
    0,
    0,
    0,
    0
};

#line 29 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qglbuffer.sip"
#include <qglbuffer.h>
#line 9609 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"



PyDoc_STRVAR(doc_QGLBuffer_type, "type(self) -> QGLBuffer.Type");

extern "C" {static PyObject *meth_QGLBuffer_type(PyObject *, PyObject *);}
static PyObject *meth_QGLBuffer_type(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLBuffer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLBuffer, &sipCpp))
        {
             ::QGLBuffer::Type sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->type();
            Py_END_ALLOW_THREADS

            return sipConvertFromEnum(static_cast<int>(sipRes), sipType_QGLBuffer_Type);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLBuffer, sipName_type, doc_QGLBuffer_type);

    return NULL;
}


PyDoc_STRVAR(doc_QGLBuffer_usagePattern, "usagePattern(self) -> QGLBuffer.UsagePattern");

extern "C" {static PyObject *meth_QGLBuffer_usagePattern(PyObject *, PyObject *);}
static PyObject *meth_QGLBuffer_usagePattern(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLBuffer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLBuffer, &sipCpp))
        {
             ::QGLBuffer::UsagePattern sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->usagePattern();
            Py_END_ALLOW_THREADS

            return sipConvertFromEnum(static_cast<int>(sipRes), sipType_QGLBuffer_UsagePattern);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLBuffer, sipName_usagePattern, doc_QGLBuffer_usagePattern);

    return NULL;
}


PyDoc_STRVAR(doc_QGLBuffer_setUsagePattern, "setUsagePattern(self, QGLBuffer.UsagePattern)");

extern "C" {static PyObject *meth_QGLBuffer_setUsagePattern(PyObject *, PyObject *);}
static PyObject *meth_QGLBuffer_setUsagePattern(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLBuffer::UsagePattern a0;
         ::QGLBuffer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QGLBuffer, &sipCpp, sipType_QGLBuffer_UsagePattern, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setUsagePattern(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLBuffer, sipName_setUsagePattern, doc_QGLBuffer_setUsagePattern);

    return NULL;
}


PyDoc_STRVAR(doc_QGLBuffer_create, "create(self) -> bool");

extern "C" {static PyObject *meth_QGLBuffer_create(PyObject *, PyObject *);}
static PyObject *meth_QGLBuffer_create(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLBuffer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLBuffer, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->create();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLBuffer, sipName_create, doc_QGLBuffer_create);

    return NULL;
}


PyDoc_STRVAR(doc_QGLBuffer_isCreated, "isCreated(self) -> bool");

extern "C" {static PyObject *meth_QGLBuffer_isCreated(PyObject *, PyObject *);}
static PyObject *meth_QGLBuffer_isCreated(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLBuffer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLBuffer, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isCreated();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLBuffer, sipName_isCreated, doc_QGLBuffer_isCreated);

    return NULL;
}


PyDoc_STRVAR(doc_QGLBuffer_destroy, "destroy(self)");

extern "C" {static PyObject *meth_QGLBuffer_destroy(PyObject *, PyObject *);}
static PyObject *meth_QGLBuffer_destroy(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLBuffer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLBuffer, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->destroy();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLBuffer, sipName_destroy, doc_QGLBuffer_destroy);

    return NULL;
}


PyDoc_STRVAR(doc_QGLBuffer_bind, "bind(self) -> bool");

extern "C" {static PyObject *meth_QGLBuffer_bind(PyObject *, PyObject *);}
static PyObject *meth_QGLBuffer_bind(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLBuffer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLBuffer, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->bind();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLBuffer, sipName_bind, doc_QGLBuffer_bind);

    return NULL;
}


PyDoc_STRVAR(doc_QGLBuffer_release, "release(self)\n"
"release(QGLBuffer.Type)");

extern "C" {static PyObject *meth_QGLBuffer_release(PyObject *, PyObject *);}
static PyObject *meth_QGLBuffer_release(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLBuffer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLBuffer, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->release();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
         ::QGLBuffer::Type a0;

        if (sipParseArgs(&sipParseErr, sipArgs, "E", sipType_QGLBuffer_Type, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
             ::QGLBuffer::release(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLBuffer, sipName_release, doc_QGLBuffer_release);

    return NULL;
}


PyDoc_STRVAR(doc_QGLBuffer_bufferId, "bufferId(self) -> int");

extern "C" {static PyObject *meth_QGLBuffer_bufferId(PyObject *, PyObject *);}
static PyObject *meth_QGLBuffer_bufferId(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLBuffer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLBuffer, &sipCpp))
        {
             ::GLuint sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->bufferId();
            Py_END_ALLOW_THREADS

            return PyLong_FromUnsignedLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLBuffer, sipName_bufferId, doc_QGLBuffer_bufferId);

    return NULL;
}


PyDoc_STRVAR(doc_QGLBuffer_size, "size(self) -> int");

extern "C" {static PyObject *meth_QGLBuffer_size(PyObject *, PyObject *);}
static PyObject *meth_QGLBuffer_size(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLBuffer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLBuffer, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->size();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLBuffer, sipName_size, doc_QGLBuffer_size);

    return NULL;
}


PyDoc_STRVAR(doc_QGLBuffer_read, "read(self, int, sip.voidptr, int) -> bool");

extern "C" {static PyObject *meth_QGLBuffer_read(PyObject *, PyObject *);}
static PyObject *meth_QGLBuffer_read(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        void* a1;
        int a2;
         ::QGLBuffer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bivi", &sipSelf, sipType_QGLBuffer, &sipCpp, &a0, &a1, &a2))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->read(a0,a1,a2);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLBuffer, sipName_read, doc_QGLBuffer_read);

    return NULL;
}


PyDoc_STRVAR(doc_QGLBuffer_write, "write(self, int, sip.voidptr, int)");

extern "C" {static PyObject *meth_QGLBuffer_write(PyObject *, PyObject *);}
static PyObject *meth_QGLBuffer_write(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        const void* a1;
        int a2;
         ::QGLBuffer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bivi", &sipSelf, sipType_QGLBuffer, &sipCpp, &a0, &a1, &a2))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->write(a0,a1,a2);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLBuffer, sipName_write, doc_QGLBuffer_write);

    return NULL;
}


PyDoc_STRVAR(doc_QGLBuffer_allocate, "allocate(self, sip.voidptr, int)\n"
"allocate(self, int)");

extern "C" {static PyObject *meth_QGLBuffer_allocate(PyObject *, PyObject *);}
static PyObject *meth_QGLBuffer_allocate(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const void* a0;
        int a1;
         ::QGLBuffer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bvi", &sipSelf, sipType_QGLBuffer, &sipCpp, &a0, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->allocate(a0,a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        int a0;
         ::QGLBuffer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QGLBuffer, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->allocate(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLBuffer, sipName_allocate, doc_QGLBuffer_allocate);

    return NULL;
}


PyDoc_STRVAR(doc_QGLBuffer_map, "map(self, QGLBuffer.Access) -> sip.voidptr");

extern "C" {static PyObject *meth_QGLBuffer_map(PyObject *, PyObject *);}
static PyObject *meth_QGLBuffer_map(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLBuffer::Access a0;
         ::QGLBuffer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QGLBuffer, &sipCpp, sipType_QGLBuffer_Access, &a0))
        {
            void*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->map(a0);
            Py_END_ALLOW_THREADS

            return sipConvertFromVoidPtr(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLBuffer, sipName_map, doc_QGLBuffer_map);

    return NULL;
}


PyDoc_STRVAR(doc_QGLBuffer_unmap, "unmap(self) -> bool");

extern "C" {static PyObject *meth_QGLBuffer_unmap(PyObject *, PyObject *);}
static PyObject *meth_QGLBuffer_unmap(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLBuffer *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLBuffer, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->unmap();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLBuffer, sipName_unmap, doc_QGLBuffer_unmap);

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QGLBuffer(void *, int);}
static void release_QGLBuffer(void *sipCppV, int)
{
    Py_BEGIN_ALLOW_THREADS

    delete reinterpret_cast< ::QGLBuffer *>(sipCppV);

    Py_END_ALLOW_THREADS
}


extern "C" {static void assign_QGLBuffer(void *, SIP_SSIZE_T, void *);}
static void assign_QGLBuffer(void *sipDst, SIP_SSIZE_T sipDstIdx, void *sipSrc)
{
    reinterpret_cast< ::QGLBuffer *>(sipDst)[sipDstIdx] = *reinterpret_cast< ::QGLBuffer *>(sipSrc);
}


extern "C" {static void *array_QGLBuffer(SIP_SSIZE_T);}
static void *array_QGLBuffer(SIP_SSIZE_T sipNrElem)
{
    return new  ::QGLBuffer[sipNrElem];
}


extern "C" {static void *copy_QGLBuffer(const void *, SIP_SSIZE_T);}
static void *copy_QGLBuffer(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new  ::QGLBuffer(reinterpret_cast<const  ::QGLBuffer *>(sipSrc)[sipSrcIdx]);
}


extern "C" {static void dealloc_QGLBuffer(sipSimpleWrapper *);}
static void dealloc_QGLBuffer(sipSimpleWrapper *sipSelf)
{
    if (sipIsOwnedByPython(sipSelf))
    {
        release_QGLBuffer(sipGetAddress(sipSelf), 0);
    }
}


extern "C" {static void *init_type_QGLBuffer(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QGLBuffer(sipSimpleWrapper *, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
     ::QGLBuffer *sipCpp = 0;

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new  ::QGLBuffer();
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    {
         ::QGLBuffer::Type a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "E", sipType_QGLBuffer_Type, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new  ::QGLBuffer(a0);
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    {
        const  ::QGLBuffer* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QGLBuffer, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new  ::QGLBuffer(*a0);
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    return NULL;
}


static PyMethodDef methods_QGLBuffer[] = {
    {SIP_MLNAME_CAST(sipName_allocate), meth_QGLBuffer_allocate, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLBuffer_allocate)},
    {SIP_MLNAME_CAST(sipName_bind), meth_QGLBuffer_bind, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLBuffer_bind)},
    {SIP_MLNAME_CAST(sipName_bufferId), meth_QGLBuffer_bufferId, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLBuffer_bufferId)},
    {SIP_MLNAME_CAST(sipName_create), meth_QGLBuffer_create, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLBuffer_create)},
    {SIP_MLNAME_CAST(sipName_destroy), meth_QGLBuffer_destroy, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLBuffer_destroy)},
    {SIP_MLNAME_CAST(sipName_isCreated), meth_QGLBuffer_isCreated, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLBuffer_isCreated)},
    {SIP_MLNAME_CAST(sipName_map), meth_QGLBuffer_map, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLBuffer_map)},
    {SIP_MLNAME_CAST(sipName_read), meth_QGLBuffer_read, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLBuffer_read)},
    {SIP_MLNAME_CAST(sipName_release), meth_QGLBuffer_release, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLBuffer_release)},
    {SIP_MLNAME_CAST(sipName_setUsagePattern), meth_QGLBuffer_setUsagePattern, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLBuffer_setUsagePattern)},
    {SIP_MLNAME_CAST(sipName_size), meth_QGLBuffer_size, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLBuffer_size)},
    {SIP_MLNAME_CAST(sipName_type), meth_QGLBuffer_type, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLBuffer_type)},
    {SIP_MLNAME_CAST(sipName_unmap), meth_QGLBuffer_unmap, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLBuffer_unmap)},
    {SIP_MLNAME_CAST(sipName_usagePattern), meth_QGLBuffer_usagePattern, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLBuffer_usagePattern)},
    {SIP_MLNAME_CAST(sipName_write), meth_QGLBuffer_write, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLBuffer_write)}
};

static sipEnumMemberDef enummembers_QGLBuffer[] = {
    {sipName_DynamicCopy, static_cast<int>( ::QGLBuffer::DynamicCopy), 6},
    {sipName_DynamicDraw, static_cast<int>( ::QGLBuffer::DynamicDraw), 6},
    {sipName_DynamicRead, static_cast<int>( ::QGLBuffer::DynamicRead), 6},
    {sipName_IndexBuffer, static_cast<int>( ::QGLBuffer::IndexBuffer), 5},
    {sipName_PixelPackBuffer, static_cast<int>( ::QGLBuffer::PixelPackBuffer), 5},
    {sipName_PixelUnpackBuffer, static_cast<int>( ::QGLBuffer::PixelUnpackBuffer), 5},
    {sipName_ReadOnly, static_cast<int>( ::QGLBuffer::ReadOnly), 4},
    {sipName_ReadWrite, static_cast<int>( ::QGLBuffer::ReadWrite), 4},
    {sipName_StaticCopy, static_cast<int>( ::QGLBuffer::StaticCopy), 6},
    {sipName_StaticDraw, static_cast<int>( ::QGLBuffer::StaticDraw), 6},
    {sipName_StaticRead, static_cast<int>( ::QGLBuffer::StaticRead), 6},
    {sipName_StreamCopy, static_cast<int>( ::QGLBuffer::StreamCopy), 6},
    {sipName_StreamDraw, static_cast<int>( ::QGLBuffer::StreamDraw), 6},
    {sipName_StreamRead, static_cast<int>( ::QGLBuffer::StreamRead), 6},
    {sipName_VertexBuffer, static_cast<int>( ::QGLBuffer::VertexBuffer), 5},
    {sipName_WriteOnly, static_cast<int>( ::QGLBuffer::WriteOnly), 4},
};

PyDoc_STRVAR(doc_QGLBuffer, "\1QGLBuffer()\n"
"QGLBuffer(QGLBuffer.Type)\n"
"QGLBuffer(QGLBuffer)");


static pyqt4ClassPluginDef plugin_QGLBuffer = {
    0,
    0,
    0
};


sipClassTypeDef sipTypeDef_QtOpenGL_QGLBuffer = {
    {
        -1,
        0,
        0,
        SIP_TYPE_CLASS,
        sipNameNr_QGLBuffer,
        {0},
        &plugin_QGLBuffer
    },
    {
        sipNameNr_QGLBuffer,
        {0, 0, 1},
        15, methods_QGLBuffer,
        16, enummembers_QGLBuffer,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QGLBuffer,
    sipNameNr_PyQt4_QtCore_pyqtWrapperType,
    sipNameNr_sip_simplewrapper,
    0,
    0,
    init_type_QGLBuffer,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QGLBuffer,
    assign_QGLBuffer,
    array_QGLBuffer,
    copy_QGLBuffer,
    release_QGLBuffer,
    0,
    0,
    0,
    0,
    0,
    0,
    0
};

#line 322 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qgl.sip"
#include <qgl.h>
#line 10293 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qwidget.sip"
#include <qwidget.h>
#line 10297 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 10300 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 225 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qgl.sip"
#include <qgl.h>
#line 10303 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 70 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qgl.sip"
#include <qgl.h>
#line 10306 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qfont.sip"
#include <qfont.h>
#line 10309 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 561 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qevent.sip"
#include <qevent.h>
#line 10312 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 524 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qevent.sip"
#include <qevent.h>
#line 10315 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 10318 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 159 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qrect.sip"
#include <qrect.h>
#line 10321 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 110 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qpoint.sip"
#include <qpoint.h>
#line 10324 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qimage.sip"
#include <qimage.h>
#line 10327 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qpixmap.sip"
#include <qpixmap.h>
#line 10330 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 27 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 10333 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 225 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qgl.sip"
#include <qgl.h>
#line 10336 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 52 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qpaintengine.sip"
#include <qpaintengine.h>
#line 10339 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qglcolormap.sip"
#include <qglcolormap.h>
#line 10342 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qcolor.sip"
#include <qcolor.h>
#line 10345 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 10348 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qmargins.sip"
#include <qmargins.h>
#line 10351 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 10354 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 10357 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qgraphicseffect.sip"
#include <qgraphicseffect.h>
#line 10360 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qgraphicsproxywidget.sip"
#include <qgraphicsproxywidget.h>
#line 10363 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qlocale.sip"
#include <qlocale.h>
#line 10366 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qpaintdevice.sip"
#include <qpaintdevice.h>
#line 10369 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qpoint.sip"
#include <qpoint.h>
#line 10372 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qregion.sip"
#include <qregion.h>
#line 10375 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qwidget.sip"
#include <qwidget.h>
#line 10378 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qpainter.sip"
#include <qpainter.h>
#line 10381 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 32 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qbytearray.sip"
#include <qbytearray.h>
#line 10384 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qsize.sip"
#include <qsize.h>
#line 10387 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qrect.sip"
#include <qrect.h>
#line 10390 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qfontinfo.sip"
#include <qfontinfo.h>
#line 10393 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qfontmetrics.sip"
#include <qfontmetrics.h>
#line 10396 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qpalette.sip"
#include <qpalette.h>
#line 10399 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 265 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qvariant.sip"
#include <qvariant.h>
#line 10402 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 647 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qevent.sip"
#include <qevent.h>
#line 10405 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 607 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qevent.sip"
#include <qevent.h>
#line 10408 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 596 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qevent.sip"
#include <qevent.h>
#line 10411 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 739 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qevent.sip"
#include <qevent.h>
#line 10414 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 792 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qevent.sip"
#include <qevent.h>
#line 10417 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 765 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qevent.sip"
#include <qevent.h>
#line 10420 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 781 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qevent.sip"
#include <qevent.h>
#line 10423 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 854 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qevent.sip"
#include <qevent.h>
#line 10426 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 403 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qevent.sip"
#include <qevent.h>
#line 10429 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 618 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qevent.sip"
#include <qevent.h>
#line 10432 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 574 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qevent.sip"
#include <qevent.h>
#line 10435 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 548 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qevent.sip"
#include <qevent.h>
#line 10438 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 505 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qevent.sip"
#include <qevent.h>
#line 10441 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 474 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qevent.sip"
#include <qevent.h>
#line 10444 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 347 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qevent.sip"
#include <qevent.h>
#line 10447 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 252 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qevent.sip"
#include <qevent.h>
#line 10450 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qinputcontext.sip"
#include <qinputcontext.h>
#line 10453 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 34 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qx11info_x11.sip"
#include <qx11info_x11.h>
#line 10456 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 115 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 10459 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qaction.sip"
#include <qaction.h>
#line 10462 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qlayout.sip"
#include <qlayout.h>
#line 10465 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qsizepolicy.sip"
#include <qsizepolicy.h>
#line 10468 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qnamespace.sip"
#include <qnamespace.h>
#line 10471 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qkeysequence.sip"
#include <qkeysequence.h>
#line 10474 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qcursor.sip"
#include <qcursor.h>
#line 10477 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qicon.sip"
#include <qicon.h>
#line 10480 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qbitmap.sip"
#include <qbitmap.h>
#line 10483 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qstyle.sip"
#include <qstyle.h>
#line 10486 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 368 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 10489 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 351 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qcoreevent.sip"
#include <qcoreevent.h>
#line 10492 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 29 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qobject.sip"
#include <qobject.h>
#line 10495 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 28 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 10498 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 115 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qlist.sip"
#include <qlist.h>
#line 10501 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qthread.sip"
#include <qthread.h>
#line 10504 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qregexp.sip"
#include <qregexp.h>
#line 10507 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qobjectdefs.sip"
#include <qobjectdefs.h>
#line 10510 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"


class sipQGLWidget : public  ::QGLWidget
{
public:
    sipQGLWidget( ::QWidget*,const  ::QGLWidget*, ::Qt::WindowFlags);
    sipQGLWidget( ::QGLContext*, ::QWidget*,const  ::QGLWidget*, ::Qt::WindowFlags);
    sipQGLWidget(const  ::QGLFormat&, ::QWidget*,const  ::QGLWidget*, ::Qt::WindowFlags);
    virtual ~sipQGLWidget();

    int qt_metacall(QMetaObject::Call,int,void **);
    void *qt_metacast(const char *);
    const QMetaObject *metaObject() const;

    /*
     * There is a public method for every protected method visible from
     * this class.
     */
     ::QObject* sipProtect_sender() const;
    int sipProtect_receivers(const char*) const;
    void sipProtectVirt_timerEvent(bool, ::QTimerEvent*);
    void sipProtectVirt_childEvent(bool, ::QChildEvent*);
    void sipProtectVirt_customEvent(bool, ::QEvent*);
    void sipProtectVirt_connectNotify(bool,const char*);
    void sipProtectVirt_disconnectNotify(bool,const char*);
    int sipProtect_senderSignalIndex() const;
    void sipProtectVirt_mousePressEvent(bool, ::QMouseEvent*);
    void sipProtectVirt_mouseReleaseEvent(bool, ::QMouseEvent*);
    void sipProtectVirt_mouseDoubleClickEvent(bool, ::QMouseEvent*);
    void sipProtectVirt_mouseMoveEvent(bool, ::QMouseEvent*);
    void sipProtectVirt_wheelEvent(bool, ::QWheelEvent*);
    void sipProtectVirt_keyPressEvent(bool, ::QKeyEvent*);
    void sipProtectVirt_keyReleaseEvent(bool, ::QKeyEvent*);
    void sipProtectVirt_focusInEvent(bool, ::QFocusEvent*);
    void sipProtectVirt_focusOutEvent(bool, ::QFocusEvent*);
    void sipProtectVirt_enterEvent(bool, ::QEvent*);
    void sipProtectVirt_leaveEvent(bool, ::QEvent*);
    void sipProtectVirt_moveEvent(bool, ::QMoveEvent*);
    void sipProtectVirt_closeEvent(bool, ::QCloseEvent*);
    void sipProtectVirt_contextMenuEvent(bool, ::QContextMenuEvent*);
    void sipProtectVirt_tabletEvent(bool, ::QTabletEvent*);
    void sipProtectVirt_actionEvent(bool, ::QActionEvent*);
    void sipProtectVirt_dragEnterEvent(bool, ::QDragEnterEvent*);
    void sipProtectVirt_dragMoveEvent(bool, ::QDragMoveEvent*);
    void sipProtectVirt_dragLeaveEvent(bool, ::QDragLeaveEvent*);
    void sipProtectVirt_dropEvent(bool, ::QDropEvent*);
    void sipProtectVirt_showEvent(bool, ::QShowEvent*);
    void sipProtectVirt_hideEvent(bool, ::QHideEvent*);
    void sipProtectVirt_changeEvent(bool, ::QEvent*);
    int sipProtectVirt_metric(bool, ::QPaintDevice::PaintDeviceMetric) const;
    void sipProtectVirt_inputMethodEvent(bool, ::QInputMethodEvent*);
    void sipProtect_resetInputContext();
    void sipProtect_updateMicroFocus();
    void sipProtect_create( ::WId,bool,bool);
    void sipProtect_destroy(bool,bool);
    bool sipProtectVirt_focusNextPrevChild(bool,bool);
    bool sipProtect_focusNextChild();
    bool sipProtect_focusPreviousChild();
    void sipProtectVirt_enabledChange(bool,bool);
    void sipProtectVirt_paletteChange(bool,const  ::QPalette&);
    void sipProtectVirt_fontChange(bool,const  ::QFont&);
    void sipProtectVirt_windowActivationChange(bool,bool);
    void sipProtectVirt_languageChange(bool);
    bool sipProtectVirt_event(bool, ::QEvent*);
    void sipProtectVirt_initializeGL(bool);
    void sipProtectVirt_resizeGL(bool,int,int);
    void sipProtectVirt_paintGL(bool);
    void sipProtectVirt_initializeOverlayGL(bool);
    void sipProtectVirt_resizeOverlayGL(bool,int,int);
    void sipProtectVirt_paintOverlayGL(bool);
    void sipProtect_setAutoBufferSwap(bool);
    bool sipProtect_autoBufferSwap() const;
    void sipProtectVirt_paintEvent(bool, ::QPaintEvent*);
    void sipProtectVirt_resizeEvent(bool, ::QResizeEvent*);
    void sipProtectVirt_glInit(bool);
    void sipProtectVirt_glDraw(bool);
    int sipProtect_fontDisplayListBase(const  ::QFont&,int);

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
    void glDraw();
    void glInit();
    void paintOverlayGL();
    void resizeOverlayGL(int,int);
    void initializeOverlayGL();
    void paintGL();
    void resizeGL(int,int);
    void initializeGL();
    void updateOverlayGL();
    void updateGL();
    void disconnectNotify(const char*);
    void connectNotify(const char*);
    void customEvent( ::QEvent*);
    void childEvent( ::QChildEvent*);
    void timerEvent( ::QTimerEvent*);
    bool eventFilter( ::QObject*, ::QEvent*);
    bool event( ::QEvent*);
    int metric( ::QPaintDevice::PaintDeviceMetric) const;
     ::QPaintEngine* paintEngine() const;
    int devType() const;
    void setVisible(bool);
     ::QSize sizeHint() const;
     ::QSize minimumSizeHint() const;
    int heightForWidth(int) const;
    void mousePressEvent( ::QMouseEvent*);
    void mouseReleaseEvent( ::QMouseEvent*);
    void mouseDoubleClickEvent( ::QMouseEvent*);
    void mouseMoveEvent( ::QMouseEvent*);
    void wheelEvent( ::QWheelEvent*);
    void keyPressEvent( ::QKeyEvent*);
    void keyReleaseEvent( ::QKeyEvent*);
    void focusInEvent( ::QFocusEvent*);
    void focusOutEvent( ::QFocusEvent*);
    void enterEvent( ::QEvent*);
    void leaveEvent( ::QEvent*);
    void paintEvent( ::QPaintEvent*);
    void moveEvent( ::QMoveEvent*);
    void resizeEvent( ::QResizeEvent*);
    void closeEvent( ::QCloseEvent*);
    void contextMenuEvent( ::QContextMenuEvent*);
    void tabletEvent( ::QTabletEvent*);
    void actionEvent( ::QActionEvent*);
    void dragEnterEvent( ::QDragEnterEvent*);
    void dragMoveEvent( ::QDragMoveEvent*);
    void dragLeaveEvent( ::QDragLeaveEvent*);
    void dropEvent( ::QDropEvent*);
    void showEvent( ::QShowEvent*);
    void hideEvent( ::QHideEvent*);
    void changeEvent( ::QEvent*);
    void inputMethodEvent( ::QInputMethodEvent*);
     ::QVariant inputMethodQuery( ::Qt::InputMethodQuery) const;
    bool focusNextPrevChild(bool);
    void enabledChange(bool);
    void paletteChange(const  ::QPalette&);
    void fontChange(const  ::QFont&);
    void windowActivationChange(bool);
    void languageChange();

public:
    sipSimpleWrapper *sipPySelf;

private:
    sipQGLWidget(const sipQGLWidget &);
    sipQGLWidget &operator = (const sipQGLWidget &);

    char sipPyMethods[57];
};

sipQGLWidget::sipQGLWidget( ::QWidget*a0,const  ::QGLWidget*a1, ::Qt::WindowFlags a2):  ::QGLWidget(a0,a1,a2), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQGLWidget::sipQGLWidget( ::QGLContext*a0, ::QWidget*a1,const  ::QGLWidget*a2, ::Qt::WindowFlags a3):  ::QGLWidget(a0,a1,a2,a3), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQGLWidget::sipQGLWidget(const  ::QGLFormat& a0, ::QWidget*a1,const  ::QGLWidget*a2, ::Qt::WindowFlags a3):  ::QGLWidget(a0,a1,a2,a3), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQGLWidget::~sipQGLWidget()
{
    sipInstanceDestroyedEx(&sipPySelf);
}

const QMetaObject *sipQGLWidget::metaObject() const
{
    return sip_QtOpenGL_qt_metaobject(sipPySelf,sipType_QGLWidget);
}

int sipQGLWidget::qt_metacall(QMetaObject::Call _c,int _id,void **_a)
{
    _id =  ::QGLWidget::qt_metacall(_c,_id,_a);

    if (_id >= 0)
        _id = sip_QtOpenGL_qt_metacall(sipPySelf,sipType_QGLWidget,_c,_id,_a);

    return _id;
}

void *sipQGLWidget::qt_metacast(const char *_clname)
{
    return (sip_QtOpenGL_qt_metacast(sipPySelf, sipType_QGLWidget, _clname)) ? this :  ::QGLWidget::qt_metacast(_clname);
}

void sipQGLWidget::glDraw()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[0],sipPySelf,NULL,sipName_glDraw);

    if (!sipMeth)
    {
         ::QGLWidget::glDraw();
        return;
    }

    extern void sipVH_QtOpenGL_1(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    sipVH_QtOpenGL_1(sipGILState, 0, sipPySelf, sipMeth);
}

void sipQGLWidget::glInit()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[1],sipPySelf,NULL,sipName_glInit);

    if (!sipMeth)
    {
         ::QGLWidget::glInit();
        return;
    }

    extern void sipVH_QtOpenGL_1(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    sipVH_QtOpenGL_1(sipGILState, 0, sipPySelf, sipMeth);
}

void sipQGLWidget::paintOverlayGL()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[2],sipPySelf,NULL,sipName_paintOverlayGL);

    if (!sipMeth)
    {
         ::QGLWidget::paintOverlayGL();
        return;
    }

    extern void sipVH_QtOpenGL_1(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    sipVH_QtOpenGL_1(sipGILState, 0, sipPySelf, sipMeth);
}

void sipQGLWidget::resizeOverlayGL(int a0,int a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[3],sipPySelf,NULL,sipName_resizeOverlayGL);

    if (!sipMeth)
    {
         ::QGLWidget::resizeOverlayGL(a0,a1);
        return;
    }

    extern void sipVH_QtOpenGL_37(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,int);

    sipVH_QtOpenGL_37(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

void sipQGLWidget::initializeOverlayGL()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[4],sipPySelf,NULL,sipName_initializeOverlayGL);

    if (!sipMeth)
    {
         ::QGLWidget::initializeOverlayGL();
        return;
    }

    extern void sipVH_QtOpenGL_1(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    sipVH_QtOpenGL_1(sipGILState, 0, sipPySelf, sipMeth);
}

void sipQGLWidget::paintGL()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[5],sipPySelf,NULL,sipName_paintGL);

    if (!sipMeth)
    {
         ::QGLWidget::paintGL();
        return;
    }

    extern void sipVH_QtOpenGL_1(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    sipVH_QtOpenGL_1(sipGILState, 0, sipPySelf, sipMeth);
}

void sipQGLWidget::resizeGL(int a0,int a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[6],sipPySelf,NULL,sipName_resizeGL);

    if (!sipMeth)
    {
         ::QGLWidget::resizeGL(a0,a1);
        return;
    }

    extern void sipVH_QtOpenGL_37(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int,int);

    sipVH_QtOpenGL_37(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

void sipQGLWidget::initializeGL()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[7],sipPySelf,NULL,sipName_initializeGL);

    if (!sipMeth)
    {
         ::QGLWidget::initializeGL();
        return;
    }

    extern void sipVH_QtOpenGL_1(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    sipVH_QtOpenGL_1(sipGILState, 0, sipPySelf, sipMeth);
}

void sipQGLWidget::updateOverlayGL()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[8],sipPySelf,NULL,sipName_updateOverlayGL);

    if (!sipMeth)
    {
         ::QGLWidget::updateOverlayGL();
        return;
    }

    extern void sipVH_QtOpenGL_1(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    sipVH_QtOpenGL_1(sipGILState, 0, sipPySelf, sipMeth);
}

void sipQGLWidget::updateGL()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[9],sipPySelf,NULL,sipName_updateGL);

    if (!sipMeth)
    {
         ::QGLWidget::updateGL();
        return;
    }

    extern void sipVH_QtOpenGL_1(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    sipVH_QtOpenGL_1(sipGILState, 0, sipPySelf, sipMeth);
}

void sipQGLWidget::disconnectNotify(const char*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[10],sipPySelf,NULL,sipName_disconnectNotify);

    if (!sipMeth)
    {
         ::QGLWidget::disconnectNotify(a0);
        return;
    }

    extern void sipVH_QtOpenGL_36(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const char*);

    sipVH_QtOpenGL_36(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLWidget::connectNotify(const char*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[11],sipPySelf,NULL,sipName_connectNotify);

    if (!sipMeth)
    {
         ::QGLWidget::connectNotify(a0);
        return;
    }

    extern void sipVH_QtOpenGL_36(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const char*);

    sipVH_QtOpenGL_36(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLWidget::customEvent( ::QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[12],sipPySelf,NULL,sipName_customEvent);

    if (!sipMeth)
    {
         ::QGLWidget::customEvent(a0);
        return;
    }

    extern void sipVH_QtOpenGL_9(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QEvent*);

    sipVH_QtOpenGL_9(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLWidget::childEvent( ::QChildEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[13],sipPySelf,NULL,sipName_childEvent);

    if (!sipMeth)
    {
         ::QGLWidget::childEvent(a0);
        return;
    }

    extern void sipVH_QtOpenGL_35(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QChildEvent*);

    sipVH_QtOpenGL_35(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLWidget::timerEvent( ::QTimerEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[14],sipPySelf,NULL,sipName_timerEvent);

    if (!sipMeth)
    {
         ::QGLWidget::timerEvent(a0);
        return;
    }

    extern void sipVH_QtOpenGL_34(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QTimerEvent*);

    sipVH_QtOpenGL_34(sipGILState, 0, sipPySelf, sipMeth, a0);
}

bool sipQGLWidget::eventFilter( ::QObject*a0, ::QEvent*a1)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[15],sipPySelf,NULL,sipName_eventFilter);

    if (!sipMeth)
        return  ::QGLWidget::eventFilter(a0,a1);

    extern bool sipVH_QtOpenGL_33(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QObject*, ::QEvent*);

    return sipVH_QtOpenGL_33(sipGILState, 0, sipPySelf, sipMeth, a0, a1);
}

bool sipQGLWidget::event( ::QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[16],sipPySelf,NULL,sipName_event);

    if (!sipMeth)
        return  ::QGLWidget::event(a0);

    extern bool sipVH_QtOpenGL_32(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QEvent*);

    return sipVH_QtOpenGL_32(sipGILState, 0, sipPySelf, sipMeth, a0);
}

int sipQGLWidget::metric( ::QPaintDevice::PaintDeviceMetric a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[17]),sipPySelf,NULL,sipName_metric);

    if (!sipMeth)
        return  ::QGLWidget::metric(a0);

    extern int sipVH_QtOpenGL_31(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QPaintDevice::PaintDeviceMetric);

    return sipVH_QtOpenGL_31(sipGILState, 0, sipPySelf, sipMeth, a0);
}

 ::QPaintEngine* sipQGLWidget::paintEngine() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[18]),sipPySelf,NULL,sipName_paintEngine);

    if (!sipMeth)
        return  ::QGLWidget::paintEngine();

    extern  ::QPaintEngine* sipVH_QtOpenGL_30(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH_QtOpenGL_30(sipGILState, 0, sipPySelf, sipMeth);
}

int sipQGLWidget::devType() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[19]),sipPySelf,NULL,sipName_devType);

    if (!sipMeth)
        return  ::QGLWidget::devType();

    extern int sipVH_QtOpenGL_29(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH_QtOpenGL_29(sipGILState, 0, sipPySelf, sipMeth);
}

void sipQGLWidget::setVisible(bool a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[20],sipPySelf,NULL,sipName_setVisible);

    if (!sipMeth)
    {
         ::QGLWidget::setVisible(a0);
        return;
    }

    extern void sipVH_QtOpenGL_3(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, bool);

    sipVH_QtOpenGL_3(sipGILState, 0, sipPySelf, sipMeth, a0);
}

 ::QSize sipQGLWidget::sizeHint() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[21]),sipPySelf,NULL,sipName_sizeHint);

    if (!sipMeth)
        return  ::QGLWidget::sizeHint();

    extern  ::QSize sipVH_QtOpenGL_28(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH_QtOpenGL_28(sipGILState, 0, sipPySelf, sipMeth);
}

 ::QSize sipQGLWidget::minimumSizeHint() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[22]),sipPySelf,NULL,sipName_minimumSizeHint);

    if (!sipMeth)
        return  ::QGLWidget::minimumSizeHint();

    extern  ::QSize sipVH_QtOpenGL_28(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH_QtOpenGL_28(sipGILState, 0, sipPySelf, sipMeth);
}

int sipQGLWidget::heightForWidth(int a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[23]),sipPySelf,NULL,sipName_heightForWidth);

    if (!sipMeth)
        return  ::QGLWidget::heightForWidth(a0);

    extern int sipVH_QtOpenGL_27(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, int);

    return sipVH_QtOpenGL_27(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLWidget::mousePressEvent( ::QMouseEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[24],sipPySelf,NULL,sipName_mousePressEvent);

    if (!sipMeth)
    {
         ::QGLWidget::mousePressEvent(a0);
        return;
    }

    extern void sipVH_QtOpenGL_26(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QMouseEvent*);

    sipVH_QtOpenGL_26(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLWidget::mouseReleaseEvent( ::QMouseEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[25],sipPySelf,NULL,sipName_mouseReleaseEvent);

    if (!sipMeth)
    {
         ::QGLWidget::mouseReleaseEvent(a0);
        return;
    }

    extern void sipVH_QtOpenGL_26(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QMouseEvent*);

    sipVH_QtOpenGL_26(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLWidget::mouseDoubleClickEvent( ::QMouseEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[26],sipPySelf,NULL,sipName_mouseDoubleClickEvent);

    if (!sipMeth)
    {
         ::QGLWidget::mouseDoubleClickEvent(a0);
        return;
    }

    extern void sipVH_QtOpenGL_26(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QMouseEvent*);

    sipVH_QtOpenGL_26(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLWidget::mouseMoveEvent( ::QMouseEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[27],sipPySelf,NULL,sipName_mouseMoveEvent);

    if (!sipMeth)
    {
         ::QGLWidget::mouseMoveEvent(a0);
        return;
    }

    extern void sipVH_QtOpenGL_26(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QMouseEvent*);

    sipVH_QtOpenGL_26(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLWidget::wheelEvent( ::QWheelEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[28],sipPySelf,NULL,sipName_wheelEvent);

    if (!sipMeth)
    {
         ::QGLWidget::wheelEvent(a0);
        return;
    }

    extern void sipVH_QtOpenGL_25(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QWheelEvent*);

    sipVH_QtOpenGL_25(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLWidget::keyPressEvent( ::QKeyEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[29],sipPySelf,NULL,sipName_keyPressEvent);

    if (!sipMeth)
    {
         ::QGLWidget::keyPressEvent(a0);
        return;
    }

    extern void sipVH_QtOpenGL_24(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QKeyEvent*);

    sipVH_QtOpenGL_24(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLWidget::keyReleaseEvent( ::QKeyEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[30],sipPySelf,NULL,sipName_keyReleaseEvent);

    if (!sipMeth)
    {
         ::QGLWidget::keyReleaseEvent(a0);
        return;
    }

    extern void sipVH_QtOpenGL_24(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QKeyEvent*);

    sipVH_QtOpenGL_24(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLWidget::focusInEvent( ::QFocusEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[31],sipPySelf,NULL,sipName_focusInEvent);

    if (!sipMeth)
    {
         ::QGLWidget::focusInEvent(a0);
        return;
    }

    extern void sipVH_QtOpenGL_23(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QFocusEvent*);

    sipVH_QtOpenGL_23(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLWidget::focusOutEvent( ::QFocusEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[32],sipPySelf,NULL,sipName_focusOutEvent);

    if (!sipMeth)
    {
         ::QGLWidget::focusOutEvent(a0);
        return;
    }

    extern void sipVH_QtOpenGL_23(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QFocusEvent*);

    sipVH_QtOpenGL_23(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLWidget::enterEvent( ::QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[33],sipPySelf,NULL,sipName_enterEvent);

    if (!sipMeth)
    {
         ::QGLWidget::enterEvent(a0);
        return;
    }

    extern void sipVH_QtOpenGL_9(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QEvent*);

    sipVH_QtOpenGL_9(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLWidget::leaveEvent( ::QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[34],sipPySelf,NULL,sipName_leaveEvent);

    if (!sipMeth)
    {
         ::QGLWidget::leaveEvent(a0);
        return;
    }

    extern void sipVH_QtOpenGL_9(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QEvent*);

    sipVH_QtOpenGL_9(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLWidget::paintEvent( ::QPaintEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[35],sipPySelf,NULL,sipName_paintEvent);

    if (!sipMeth)
    {
         ::QGLWidget::paintEvent(a0);
        return;
    }

    extern void sipVH_QtOpenGL_22(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QPaintEvent*);

    sipVH_QtOpenGL_22(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLWidget::moveEvent( ::QMoveEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[36],sipPySelf,NULL,sipName_moveEvent);

    if (!sipMeth)
    {
         ::QGLWidget::moveEvent(a0);
        return;
    }

    extern void sipVH_QtOpenGL_21(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QMoveEvent*);

    sipVH_QtOpenGL_21(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLWidget::resizeEvent( ::QResizeEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[37],sipPySelf,NULL,sipName_resizeEvent);

    if (!sipMeth)
    {
         ::QGLWidget::resizeEvent(a0);
        return;
    }

    extern void sipVH_QtOpenGL_20(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QResizeEvent*);

    sipVH_QtOpenGL_20(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLWidget::closeEvent( ::QCloseEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[38],sipPySelf,NULL,sipName_closeEvent);

    if (!sipMeth)
    {
         ::QGLWidget::closeEvent(a0);
        return;
    }

    extern void sipVH_QtOpenGL_19(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QCloseEvent*);

    sipVH_QtOpenGL_19(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLWidget::contextMenuEvent( ::QContextMenuEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[39],sipPySelf,NULL,sipName_contextMenuEvent);

    if (!sipMeth)
    {
         ::QGLWidget::contextMenuEvent(a0);
        return;
    }

    extern void sipVH_QtOpenGL_18(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QContextMenuEvent*);

    sipVH_QtOpenGL_18(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLWidget::tabletEvent( ::QTabletEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[40],sipPySelf,NULL,sipName_tabletEvent);

    if (!sipMeth)
    {
         ::QGLWidget::tabletEvent(a0);
        return;
    }

    extern void sipVH_QtOpenGL_17(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QTabletEvent*);

    sipVH_QtOpenGL_17(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLWidget::actionEvent( ::QActionEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[41],sipPySelf,NULL,sipName_actionEvent);

    if (!sipMeth)
    {
         ::QGLWidget::actionEvent(a0);
        return;
    }

    extern void sipVH_QtOpenGL_16(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QActionEvent*);

    sipVH_QtOpenGL_16(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLWidget::dragEnterEvent( ::QDragEnterEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[42],sipPySelf,NULL,sipName_dragEnterEvent);

    if (!sipMeth)
    {
         ::QGLWidget::dragEnterEvent(a0);
        return;
    }

    extern void sipVH_QtOpenGL_15(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QDragEnterEvent*);

    sipVH_QtOpenGL_15(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLWidget::dragMoveEvent( ::QDragMoveEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[43],sipPySelf,NULL,sipName_dragMoveEvent);

    if (!sipMeth)
    {
         ::QGLWidget::dragMoveEvent(a0);
        return;
    }

    extern void sipVH_QtOpenGL_14(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QDragMoveEvent*);

    sipVH_QtOpenGL_14(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLWidget::dragLeaveEvent( ::QDragLeaveEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[44],sipPySelf,NULL,sipName_dragLeaveEvent);

    if (!sipMeth)
    {
         ::QGLWidget::dragLeaveEvent(a0);
        return;
    }

    extern void sipVH_QtOpenGL_13(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QDragLeaveEvent*);

    sipVH_QtOpenGL_13(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLWidget::dropEvent( ::QDropEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[45],sipPySelf,NULL,sipName_dropEvent);

    if (!sipMeth)
    {
         ::QGLWidget::dropEvent(a0);
        return;
    }

    extern void sipVH_QtOpenGL_12(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QDropEvent*);

    sipVH_QtOpenGL_12(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLWidget::showEvent( ::QShowEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[46],sipPySelf,NULL,sipName_showEvent);

    if (!sipMeth)
    {
         ::QGLWidget::showEvent(a0);
        return;
    }

    extern void sipVH_QtOpenGL_11(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QShowEvent*);

    sipVH_QtOpenGL_11(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLWidget::hideEvent( ::QHideEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[47],sipPySelf,NULL,sipName_hideEvent);

    if (!sipMeth)
    {
         ::QGLWidget::hideEvent(a0);
        return;
    }

    extern void sipVH_QtOpenGL_10(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QHideEvent*);

    sipVH_QtOpenGL_10(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLWidget::changeEvent( ::QEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[48],sipPySelf,NULL,sipName_changeEvent);

    if (!sipMeth)
    {
         ::QGLWidget::changeEvent(a0);
        return;
    }

    extern void sipVH_QtOpenGL_9(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QEvent*);

    sipVH_QtOpenGL_9(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLWidget::inputMethodEvent( ::QInputMethodEvent*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[49],sipPySelf,NULL,sipName_inputMethodEvent);

    if (!sipMeth)
    {
         ::QGLWidget::inputMethodEvent(a0);
        return;
    }

    extern void sipVH_QtOpenGL_8(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::QInputMethodEvent*);

    sipVH_QtOpenGL_8(sipGILState, 0, sipPySelf, sipMeth, a0);
}

 ::QVariant sipQGLWidget::inputMethodQuery( ::Qt::InputMethodQuery a0) const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[50]),sipPySelf,NULL,sipName_inputMethodQuery);

    if (!sipMeth)
        return  ::QGLWidget::inputMethodQuery(a0);

    extern  ::QVariant sipVH_QtOpenGL_7(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *,  ::Qt::InputMethodQuery);

    return sipVH_QtOpenGL_7(sipGILState, 0, sipPySelf, sipMeth, a0);
}

bool sipQGLWidget::focusNextPrevChild(bool a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[51],sipPySelf,NULL,sipName_focusNextPrevChild);

    if (!sipMeth)
        return  ::QGLWidget::focusNextPrevChild(a0);

    extern bool sipVH_QtOpenGL_6(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, bool);

    return sipVH_QtOpenGL_6(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLWidget::enabledChange(bool a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[52],sipPySelf,NULL,sipName_enabledChange);

    if (!sipMeth)
    {
         ::QGLWidget::enabledChange(a0);
        return;
    }

    extern void sipVH_QtOpenGL_3(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, bool);

    sipVH_QtOpenGL_3(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLWidget::paletteChange(const  ::QPalette& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[53],sipPySelf,NULL,sipName_paletteChange);

    if (!sipMeth)
    {
         ::QGLWidget::paletteChange(a0);
        return;
    }

    extern void sipVH_QtOpenGL_5(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const  ::QPalette&);

    sipVH_QtOpenGL_5(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLWidget::fontChange(const  ::QFont& a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[54],sipPySelf,NULL,sipName_fontChange);

    if (!sipMeth)
    {
         ::QGLWidget::fontChange(a0);
        return;
    }

    extern void sipVH_QtOpenGL_4(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const  ::QFont&);

    sipVH_QtOpenGL_4(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLWidget::windowActivationChange(bool a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[55],sipPySelf,NULL,sipName_windowActivationChange);

    if (!sipMeth)
    {
         ::QGLWidget::windowActivationChange(a0);
        return;
    }

    extern void sipVH_QtOpenGL_3(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, bool);

    sipVH_QtOpenGL_3(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void sipQGLWidget::languageChange()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[56],sipPySelf,NULL,sipName_languageChange);

    if (!sipMeth)
    {
         ::QGLWidget::languageChange();
        return;
    }

    extern void sipVH_QtOpenGL_1(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    sipVH_QtOpenGL_1(sipGILState, 0, sipPySelf, sipMeth);
}

 ::QObject* sipQGLWidget::sipProtect_sender() const
{
    return  ::QObject::sender();
}

int sipQGLWidget::sipProtect_receivers(const char*a0) const
{
    return  ::QObject::receivers(a0);
}

void sipQGLWidget::sipProtectVirt_timerEvent(bool sipSelfWasArg, ::QTimerEvent*a0)
{
    (sipSelfWasArg ?  ::QObject::timerEvent(a0) : timerEvent(a0));
}

void sipQGLWidget::sipProtectVirt_childEvent(bool sipSelfWasArg, ::QChildEvent*a0)
{
    (sipSelfWasArg ?  ::QObject::childEvent(a0) : childEvent(a0));
}

void sipQGLWidget::sipProtectVirt_customEvent(bool sipSelfWasArg, ::QEvent*a0)
{
    (sipSelfWasArg ?  ::QObject::customEvent(a0) : customEvent(a0));
}

void sipQGLWidget::sipProtectVirt_connectNotify(bool sipSelfWasArg,const char*a0)
{
    (sipSelfWasArg ?  ::QObject::connectNotify(a0) : connectNotify(a0));
}

void sipQGLWidget::sipProtectVirt_disconnectNotify(bool sipSelfWasArg,const char*a0)
{
    (sipSelfWasArg ?  ::QObject::disconnectNotify(a0) : disconnectNotify(a0));
}

int sipQGLWidget::sipProtect_senderSignalIndex() const
{
    return  ::QObject::senderSignalIndex();
}

void sipQGLWidget::sipProtectVirt_mousePressEvent(bool sipSelfWasArg, ::QMouseEvent*a0)
{
    (sipSelfWasArg ?  ::QWidget::mousePressEvent(a0) : mousePressEvent(a0));
}

void sipQGLWidget::sipProtectVirt_mouseReleaseEvent(bool sipSelfWasArg, ::QMouseEvent*a0)
{
    (sipSelfWasArg ?  ::QWidget::mouseReleaseEvent(a0) : mouseReleaseEvent(a0));
}

void sipQGLWidget::sipProtectVirt_mouseDoubleClickEvent(bool sipSelfWasArg, ::QMouseEvent*a0)
{
    (sipSelfWasArg ?  ::QWidget::mouseDoubleClickEvent(a0) : mouseDoubleClickEvent(a0));
}

void sipQGLWidget::sipProtectVirt_mouseMoveEvent(bool sipSelfWasArg, ::QMouseEvent*a0)
{
    (sipSelfWasArg ?  ::QWidget::mouseMoveEvent(a0) : mouseMoveEvent(a0));
}

void sipQGLWidget::sipProtectVirt_wheelEvent(bool sipSelfWasArg, ::QWheelEvent*a0)
{
    (sipSelfWasArg ?  ::QWidget::wheelEvent(a0) : wheelEvent(a0));
}

void sipQGLWidget::sipProtectVirt_keyPressEvent(bool sipSelfWasArg, ::QKeyEvent*a0)
{
    (sipSelfWasArg ?  ::QWidget::keyPressEvent(a0) : keyPressEvent(a0));
}

void sipQGLWidget::sipProtectVirt_keyReleaseEvent(bool sipSelfWasArg, ::QKeyEvent*a0)
{
    (sipSelfWasArg ?  ::QWidget::keyReleaseEvent(a0) : keyReleaseEvent(a0));
}

void sipQGLWidget::sipProtectVirt_focusInEvent(bool sipSelfWasArg, ::QFocusEvent*a0)
{
    (sipSelfWasArg ?  ::QWidget::focusInEvent(a0) : focusInEvent(a0));
}

void sipQGLWidget::sipProtectVirt_focusOutEvent(bool sipSelfWasArg, ::QFocusEvent*a0)
{
    (sipSelfWasArg ?  ::QWidget::focusOutEvent(a0) : focusOutEvent(a0));
}

void sipQGLWidget::sipProtectVirt_enterEvent(bool sipSelfWasArg, ::QEvent*a0)
{
    (sipSelfWasArg ?  ::QWidget::enterEvent(a0) : enterEvent(a0));
}

void sipQGLWidget::sipProtectVirt_leaveEvent(bool sipSelfWasArg, ::QEvent*a0)
{
    (sipSelfWasArg ?  ::QWidget::leaveEvent(a0) : leaveEvent(a0));
}

void sipQGLWidget::sipProtectVirt_moveEvent(bool sipSelfWasArg, ::QMoveEvent*a0)
{
    (sipSelfWasArg ?  ::QWidget::moveEvent(a0) : moveEvent(a0));
}

void sipQGLWidget::sipProtectVirt_closeEvent(bool sipSelfWasArg, ::QCloseEvent*a0)
{
    (sipSelfWasArg ?  ::QWidget::closeEvent(a0) : closeEvent(a0));
}

void sipQGLWidget::sipProtectVirt_contextMenuEvent(bool sipSelfWasArg, ::QContextMenuEvent*a0)
{
    (sipSelfWasArg ?  ::QWidget::contextMenuEvent(a0) : contextMenuEvent(a0));
}

void sipQGLWidget::sipProtectVirt_tabletEvent(bool sipSelfWasArg, ::QTabletEvent*a0)
{
    (sipSelfWasArg ?  ::QWidget::tabletEvent(a0) : tabletEvent(a0));
}

void sipQGLWidget::sipProtectVirt_actionEvent(bool sipSelfWasArg, ::QActionEvent*a0)
{
    (sipSelfWasArg ?  ::QWidget::actionEvent(a0) : actionEvent(a0));
}

void sipQGLWidget::sipProtectVirt_dragEnterEvent(bool sipSelfWasArg, ::QDragEnterEvent*a0)
{
    (sipSelfWasArg ?  ::QWidget::dragEnterEvent(a0) : dragEnterEvent(a0));
}

void sipQGLWidget::sipProtectVirt_dragMoveEvent(bool sipSelfWasArg, ::QDragMoveEvent*a0)
{
    (sipSelfWasArg ?  ::QWidget::dragMoveEvent(a0) : dragMoveEvent(a0));
}

void sipQGLWidget::sipProtectVirt_dragLeaveEvent(bool sipSelfWasArg, ::QDragLeaveEvent*a0)
{
    (sipSelfWasArg ?  ::QWidget::dragLeaveEvent(a0) : dragLeaveEvent(a0));
}

void sipQGLWidget::sipProtectVirt_dropEvent(bool sipSelfWasArg, ::QDropEvent*a0)
{
    (sipSelfWasArg ?  ::QWidget::dropEvent(a0) : dropEvent(a0));
}

void sipQGLWidget::sipProtectVirt_showEvent(bool sipSelfWasArg, ::QShowEvent*a0)
{
    (sipSelfWasArg ?  ::QWidget::showEvent(a0) : showEvent(a0));
}

void sipQGLWidget::sipProtectVirt_hideEvent(bool sipSelfWasArg, ::QHideEvent*a0)
{
    (sipSelfWasArg ?  ::QWidget::hideEvent(a0) : hideEvent(a0));
}

void sipQGLWidget::sipProtectVirt_changeEvent(bool sipSelfWasArg, ::QEvent*a0)
{
    (sipSelfWasArg ?  ::QWidget::changeEvent(a0) : changeEvent(a0));
}

int sipQGLWidget::sipProtectVirt_metric(bool sipSelfWasArg, ::QPaintDevice::PaintDeviceMetric a0) const
{
    return (sipSelfWasArg ?  ::QWidget::metric(a0) : metric(a0));
}

void sipQGLWidget::sipProtectVirt_inputMethodEvent(bool sipSelfWasArg, ::QInputMethodEvent*a0)
{
    (sipSelfWasArg ?  ::QWidget::inputMethodEvent(a0) : inputMethodEvent(a0));
}

void sipQGLWidget::sipProtect_resetInputContext()
{
     ::QWidget::resetInputContext();
}

void sipQGLWidget::sipProtect_updateMicroFocus()
{
     ::QWidget::updateMicroFocus();
}

void sipQGLWidget::sipProtect_create( ::WId a0,bool a1,bool a2)
{
     ::QWidget::create(a0,a1,a2);
}

void sipQGLWidget::sipProtect_destroy(bool a0,bool a1)
{
     ::QWidget::destroy(a0,a1);
}

bool sipQGLWidget::sipProtectVirt_focusNextPrevChild(bool sipSelfWasArg,bool a0)
{
    return (sipSelfWasArg ?  ::QWidget::focusNextPrevChild(a0) : focusNextPrevChild(a0));
}

bool sipQGLWidget::sipProtect_focusNextChild()
{
    return  ::QWidget::focusNextChild();
}

bool sipQGLWidget::sipProtect_focusPreviousChild()
{
    return  ::QWidget::focusPreviousChild();
}

void sipQGLWidget::sipProtectVirt_enabledChange(bool sipSelfWasArg,bool a0)
{
    (sipSelfWasArg ?  ::QWidget::enabledChange(a0) : enabledChange(a0));
}

void sipQGLWidget::sipProtectVirt_paletteChange(bool sipSelfWasArg,const  ::QPalette& a0)
{
    (sipSelfWasArg ?  ::QWidget::paletteChange(a0) : paletteChange(a0));
}

void sipQGLWidget::sipProtectVirt_fontChange(bool sipSelfWasArg,const  ::QFont& a0)
{
    (sipSelfWasArg ?  ::QWidget::fontChange(a0) : fontChange(a0));
}

void sipQGLWidget::sipProtectVirt_windowActivationChange(bool sipSelfWasArg,bool a0)
{
    (sipSelfWasArg ?  ::QWidget::windowActivationChange(a0) : windowActivationChange(a0));
}

void sipQGLWidget::sipProtectVirt_languageChange(bool sipSelfWasArg)
{
    (sipSelfWasArg ?  ::QWidget::languageChange() : languageChange());
}

bool sipQGLWidget::sipProtectVirt_event(bool sipSelfWasArg, ::QEvent*a0)
{
    return (sipSelfWasArg ?  ::QGLWidget::event(a0) : event(a0));
}

void sipQGLWidget::sipProtectVirt_initializeGL(bool sipSelfWasArg)
{
    (sipSelfWasArg ?  ::QGLWidget::initializeGL() : initializeGL());
}

void sipQGLWidget::sipProtectVirt_resizeGL(bool sipSelfWasArg,int a0,int a1)
{
    (sipSelfWasArg ?  ::QGLWidget::resizeGL(a0,a1) : resizeGL(a0,a1));
}

void sipQGLWidget::sipProtectVirt_paintGL(bool sipSelfWasArg)
{
    (sipSelfWasArg ?  ::QGLWidget::paintGL() : paintGL());
}

void sipQGLWidget::sipProtectVirt_initializeOverlayGL(bool sipSelfWasArg)
{
    (sipSelfWasArg ?  ::QGLWidget::initializeOverlayGL() : initializeOverlayGL());
}

void sipQGLWidget::sipProtectVirt_resizeOverlayGL(bool sipSelfWasArg,int a0,int a1)
{
    (sipSelfWasArg ?  ::QGLWidget::resizeOverlayGL(a0,a1) : resizeOverlayGL(a0,a1));
}

void sipQGLWidget::sipProtectVirt_paintOverlayGL(bool sipSelfWasArg)
{
    (sipSelfWasArg ?  ::QGLWidget::paintOverlayGL() : paintOverlayGL());
}

void sipQGLWidget::sipProtect_setAutoBufferSwap(bool a0)
{
     ::QGLWidget::setAutoBufferSwap(a0);
}

bool sipQGLWidget::sipProtect_autoBufferSwap() const
{
    return  ::QGLWidget::autoBufferSwap();
}

void sipQGLWidget::sipProtectVirt_paintEvent(bool sipSelfWasArg, ::QPaintEvent*a0)
{
    (sipSelfWasArg ?  ::QGLWidget::paintEvent(a0) : paintEvent(a0));
}

void sipQGLWidget::sipProtectVirt_resizeEvent(bool sipSelfWasArg, ::QResizeEvent*a0)
{
    (sipSelfWasArg ?  ::QGLWidget::resizeEvent(a0) : resizeEvent(a0));
}

void sipQGLWidget::sipProtectVirt_glInit(bool sipSelfWasArg)
{
    (sipSelfWasArg ?  ::QGLWidget::glInit() : glInit());
}

void sipQGLWidget::sipProtectVirt_glDraw(bool sipSelfWasArg)
{
    (sipSelfWasArg ?  ::QGLWidget::glDraw() : glDraw());
}

int sipQGLWidget::sipProtect_fontDisplayListBase(const  ::QFont& a0,int a1)
{
    return  ::QGLWidget::fontDisplayListBase(a0,a1);
}


PyDoc_STRVAR(doc_QGLWidget_sender, "sender(self) -> QObject");

extern "C" {static PyObject *meth_QGLWidget_sender(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_sender(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QGLWidget, &sipCpp))
        {
             ::QObject*sipRes = 0;

#line 678 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qobject.sip"
        typedef QObject *(*helper_func)(QObject *);
        
        static helper_func helper = 0;
        
        if (!helper)
        {
            helper = (helper_func)sipImportSymbol("qpycore_qobject_sender");
            Q_ASSERT(helper);
        }
        
        // sender() must be called without the GIL to avoid possible deadlocks between
        // the GIL and Qt's internal thread data mutex.
        
        Py_BEGIN_ALLOW_THREADS
        
        #if defined(SIP_PROTECTED_IS_PUBLIC)
        sipRes = sipCpp->sender();
        #else
        sipRes = sipCpp->sipProtect_sender();
        #endif
        
        Py_END_ALLOW_THREADS
        
        sipRes = helper(sipRes);
#line 12034 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

            return sipConvertFromType(sipRes,sipType_QObject,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_sender, doc_QGLWidget_sender);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_receivers, "receivers(self, QT_SIGNAL) -> int");

extern "C" {static PyObject *meth_QGLWidget_receivers(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_receivers(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        PyObject * a0;
        const sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BP0", &sipSelf, sipType_QGLWidget, &sipCpp, &a0))
        {
            int sipRes = 0;
            sipErrorState sipError = sipErrorNone;

#line 706 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qobject.sip"
        // We need to take into account any proxies for Python signals. Import the
        // helpers if it hasn't already been done.
        typedef const char *(*pyqt4_get_signal_t)(PyObject *);
        typedef int (*receivers_helper_func)(QObject *, const char *, int);
        
        static pyqt4_get_signal_t pyqt4_get_signal = 0;
        static receivers_helper_func receivers_helper = 0;
        
        if (!pyqt4_get_signal)
        {
            pyqt4_get_signal = (pyqt4_get_signal_t)sipImportSymbol("pyqt4_get_signal");
            Q_ASSERT(pyqt4_get_signal);
        }
        
        if (!receivers_helper)
        {
            receivers_helper = (receivers_helper_func)sipImportSymbol("qpycore_qobject_receivers");
            Q_ASSERT(receivers_helper);
        }
        
        // PyQt5: Get rid of the const casts.
        const char *sig = pyqt4_get_signal(a0);
            
        if (sig)
        {
        #if defined(SIP_PROTECTED_IS_PUBLIC)
            sipRes = receivers_helper(const_cast<QObject *>(sipCpp), sig, sipCpp->receivers(sig));
        #else
            sipRes = receivers_helper(const_cast<QObject *>(static_cast<const QObject *>(sipCpp)), sig, sipCpp->sipProtect_receivers(sig));
        #endif
        }
        else
        {
            sipError = sipBadCallableArg(0, a0);
        }
#line 12100 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            return SIPLong_FromLong(sipRes);
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_receivers, doc_QGLWidget_receivers);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_timerEvent, "timerEvent(self, QTimerEvent)");

extern "C" {static PyObject *meth_QGLWidget_timerEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_timerEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QTimerEvent* a0;
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QTimerEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_timerEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_timerEvent, doc_QGLWidget_timerEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_childEvent, "childEvent(self, QChildEvent)");

extern "C" {static PyObject *meth_QGLWidget_childEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_childEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QChildEvent* a0;
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QChildEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_childEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_childEvent, doc_QGLWidget_childEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_customEvent, "customEvent(self, QEvent)");

extern "C" {static PyObject *meth_QGLWidget_customEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_customEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QEvent* a0;
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_customEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_customEvent, doc_QGLWidget_customEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_connectNotify, "connectNotify(self, QT_SIGNAL)");

extern "C" {static PyObject *meth_QGLWidget_connectNotify(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_connectNotify(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        PyObject * a0;
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BP0", &sipSelf, sipType_QGLWidget, &sipCpp, &a0))
        {
            sipErrorState sipError = sipErrorNone;

#line 752 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qobject.sip"
        typedef const char *(*pyqt4_get_signal_t)(PyObject *);
        
        static pyqt4_get_signal_t pyqt4_get_signal = 0;
        
        if (!pyqt4_get_signal)
        {
            pyqt4_get_signal = (pyqt4_get_signal_t)sipImportSymbol("pyqt4_get_signal");
            Q_ASSERT(pyqt4_get_signal);
        }
        
        const char *sig = pyqt4_get_signal(a0);
            
        if (sig)
        {
        #if defined(SIP_PROTECTED_IS_PUBLIC)
            (sipSelfWasArg ? sipCpp->QObject::connectNotify(sig) : sipCpp->connectNotify(sig));
        #else
            sipCpp->sipProtectVirt_connectNotify(sipSelfWasArg, sig);
        #endif
        }
        else
        {
            sipError = sipBadCallableArg(0, a0);
        }
#line 12256 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_connectNotify, doc_QGLWidget_connectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_disconnectNotify, "disconnectNotify(self, QT_SIGNAL)");

extern "C" {static PyObject *meth_QGLWidget_disconnectNotify(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_disconnectNotify(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        PyObject * a0;
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BP0", &sipSelf, sipType_QGLWidget, &sipCpp, &a0))
        {
            sipErrorState sipError = sipErrorNone;

#line 785 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qobject.sip"
        typedef const char *(*pyqt4_get_signal_t)(PyObject *);
        
        static pyqt4_get_signal_t pyqt4_get_signal = 0;
        
        if (!pyqt4_get_signal)
        {
            pyqt4_get_signal = (pyqt4_get_signal_t)sipImportSymbol("pyqt4_get_signal");
            Q_ASSERT(pyqt4_get_signal);
        }
        
        const char *sig = pyqt4_get_signal(a0);
            
        if (sig)
        {
        #if defined(SIP_PROTECTED_IS_PUBLIC)
            (sipSelfWasArg ? sipCpp->QObject::disconnectNotify(sig) : sipCpp->disconnectNotify(sig));
        #else
            sipCpp->sipProtectVirt_disconnectNotify(sipSelfWasArg, sig);
        #endif
        }
        else
        {
            sipError = sipBadCallableArg(0, a0);
        }
#line 12320 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

            if (sipError == sipErrorFail)
                return 0;

            if (sipError == sipErrorNone)
            {
            Py_INCREF(Py_None);
            return Py_None;
            }

            sipAddException(sipError, &sipParseErr);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_disconnectNotify, doc_QGLWidget_disconnectNotify);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_senderSignalIndex, "senderSignalIndex(self) -> int");

extern "C" {static PyObject *meth_QGLWidget_senderSignalIndex(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_senderSignalIndex(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QGLWidget, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_senderSignalIndex();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_senderSignalIndex, doc_QGLWidget_senderSignalIndex);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_mousePressEvent, "mousePressEvent(self, QMouseEvent)");

extern "C" {static PyObject *meth_QGLWidget_mousePressEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_mousePressEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QMouseEvent* a0;
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QMouseEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_mousePressEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_mousePressEvent, doc_QGLWidget_mousePressEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_mouseReleaseEvent, "mouseReleaseEvent(self, QMouseEvent)");

extern "C" {static PyObject *meth_QGLWidget_mouseReleaseEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_mouseReleaseEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QMouseEvent* a0;
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QMouseEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_mouseReleaseEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_mouseReleaseEvent, doc_QGLWidget_mouseReleaseEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_mouseDoubleClickEvent, "mouseDoubleClickEvent(self, QMouseEvent)");

extern "C" {static PyObject *meth_QGLWidget_mouseDoubleClickEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_mouseDoubleClickEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QMouseEvent* a0;
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QMouseEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_mouseDoubleClickEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_mouseDoubleClickEvent, doc_QGLWidget_mouseDoubleClickEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_mouseMoveEvent, "mouseMoveEvent(self, QMouseEvent)");

extern "C" {static PyObject *meth_QGLWidget_mouseMoveEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_mouseMoveEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QMouseEvent* a0;
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QMouseEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_mouseMoveEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_mouseMoveEvent, doc_QGLWidget_mouseMoveEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_wheelEvent, "wheelEvent(self, QWheelEvent)");

extern "C" {static PyObject *meth_QGLWidget_wheelEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_wheelEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QWheelEvent* a0;
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QWheelEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_wheelEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_wheelEvent, doc_QGLWidget_wheelEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_keyPressEvent, "keyPressEvent(self, QKeyEvent)");

extern "C" {static PyObject *meth_QGLWidget_keyPressEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_keyPressEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QKeyEvent* a0;
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QKeyEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_keyPressEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_keyPressEvent, doc_QGLWidget_keyPressEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_keyReleaseEvent, "keyReleaseEvent(self, QKeyEvent)");

extern "C" {static PyObject *meth_QGLWidget_keyReleaseEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_keyReleaseEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QKeyEvent* a0;
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QKeyEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_keyReleaseEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_keyReleaseEvent, doc_QGLWidget_keyReleaseEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_focusInEvent, "focusInEvent(self, QFocusEvent)");

extern "C" {static PyObject *meth_QGLWidget_focusInEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_focusInEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QFocusEvent* a0;
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QFocusEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_focusInEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_focusInEvent, doc_QGLWidget_focusInEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_focusOutEvent, "focusOutEvent(self, QFocusEvent)");

extern "C" {static PyObject *meth_QGLWidget_focusOutEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_focusOutEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QFocusEvent* a0;
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QFocusEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_focusOutEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_focusOutEvent, doc_QGLWidget_focusOutEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_enterEvent, "enterEvent(self, QEvent)");

extern "C" {static PyObject *meth_QGLWidget_enterEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_enterEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QEvent* a0;
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_enterEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_enterEvent, doc_QGLWidget_enterEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_leaveEvent, "leaveEvent(self, QEvent)");

extern "C" {static PyObject *meth_QGLWidget_leaveEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_leaveEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QEvent* a0;
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_leaveEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_leaveEvent, doc_QGLWidget_leaveEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_moveEvent, "moveEvent(self, QMoveEvent)");

extern "C" {static PyObject *meth_QGLWidget_moveEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_moveEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QMoveEvent* a0;
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QMoveEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_moveEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_moveEvent, doc_QGLWidget_moveEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_closeEvent, "closeEvent(self, QCloseEvent)");

extern "C" {static PyObject *meth_QGLWidget_closeEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_closeEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QCloseEvent* a0;
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QCloseEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_closeEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_closeEvent, doc_QGLWidget_closeEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_contextMenuEvent, "contextMenuEvent(self, QContextMenuEvent)");

extern "C" {static PyObject *meth_QGLWidget_contextMenuEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_contextMenuEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QContextMenuEvent* a0;
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QContextMenuEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_contextMenuEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_contextMenuEvent, doc_QGLWidget_contextMenuEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_tabletEvent, "tabletEvent(self, QTabletEvent)");

extern "C" {static PyObject *meth_QGLWidget_tabletEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_tabletEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QTabletEvent* a0;
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QTabletEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_tabletEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_tabletEvent, doc_QGLWidget_tabletEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_actionEvent, "actionEvent(self, QActionEvent)");

extern "C" {static PyObject *meth_QGLWidget_actionEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_actionEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QActionEvent* a0;
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QActionEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_actionEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_actionEvent, doc_QGLWidget_actionEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_dragEnterEvent, "dragEnterEvent(self, QDragEnterEvent)");

extern "C" {static PyObject *meth_QGLWidget_dragEnterEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_dragEnterEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QDragEnterEvent* a0;
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QDragEnterEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_dragEnterEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_dragEnterEvent, doc_QGLWidget_dragEnterEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_dragMoveEvent, "dragMoveEvent(self, QDragMoveEvent)");

extern "C" {static PyObject *meth_QGLWidget_dragMoveEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_dragMoveEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QDragMoveEvent* a0;
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QDragMoveEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_dragMoveEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_dragMoveEvent, doc_QGLWidget_dragMoveEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_dragLeaveEvent, "dragLeaveEvent(self, QDragLeaveEvent)");

extern "C" {static PyObject *meth_QGLWidget_dragLeaveEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_dragLeaveEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QDragLeaveEvent* a0;
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QDragLeaveEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_dragLeaveEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_dragLeaveEvent, doc_QGLWidget_dragLeaveEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_dropEvent, "dropEvent(self, QDropEvent)");

extern "C" {static PyObject *meth_QGLWidget_dropEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_dropEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QDropEvent* a0;
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QDropEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_dropEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_dropEvent, doc_QGLWidget_dropEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_showEvent, "showEvent(self, QShowEvent)");

extern "C" {static PyObject *meth_QGLWidget_showEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_showEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QShowEvent* a0;
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QShowEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_showEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_showEvent, doc_QGLWidget_showEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_hideEvent, "hideEvent(self, QHideEvent)");

extern "C" {static PyObject *meth_QGLWidget_hideEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_hideEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QHideEvent* a0;
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QHideEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_hideEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_hideEvent, doc_QGLWidget_hideEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_changeEvent, "changeEvent(self, QEvent)");

extern "C" {static PyObject *meth_QGLWidget_changeEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_changeEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QEvent* a0;
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_changeEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_changeEvent, doc_QGLWidget_changeEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_metric, "metric(self, QPaintDevice.PaintDeviceMetric) -> int");

extern "C" {static PyObject *meth_QGLWidget_metric(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_metric(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QPaintDevice::PaintDeviceMetric a0;
        const sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BE", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QPaintDevice_PaintDeviceMetric, &a0))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtectVirt_metric(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_metric, doc_QGLWidget_metric);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_inputMethodEvent, "inputMethodEvent(self, QInputMethodEvent)");

extern "C" {static PyObject *meth_QGLWidget_inputMethodEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_inputMethodEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QInputMethodEvent* a0;
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QInputMethodEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_inputMethodEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_inputMethodEvent, doc_QGLWidget_inputMethodEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_resetInputContext, "resetInputContext(self)");

extern "C" {static PyObject *meth_QGLWidget_resetInputContext(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_resetInputContext(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QGLWidget, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_resetInputContext();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_resetInputContext, doc_QGLWidget_resetInputContext);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_updateMicroFocus, "updateMicroFocus(self)");

extern "C" {static PyObject *meth_QGLWidget_updateMicroFocus(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_updateMicroFocus(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QGLWidget, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_updateMicroFocus();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_updateMicroFocus, doc_QGLWidget_updateMicroFocus);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_create, "create(self, window: int = 0, initializeWindow: bool = True, destroyOldWindow: bool = True)");

extern "C" {static PyObject *meth_QGLWidget_create(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_create(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
         ::WId a0 = 0;
        bool a1 = 1;
        bool a2 = 1;
        sipQGLWidget *sipCpp;

        static const char *sipKwdList[] = {
            sipName_window,
            sipName_initializeWindow,
            sipName_destroyOldWindow,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "B|mbb", &sipSelf, sipType_QGLWidget, &sipCpp, &a0, &a1, &a2))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_create(a0,a1,a2);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_create, doc_QGLWidget_create);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_destroy, "destroy(self, destroyWindow: bool = True, destroySubWindows: bool = True)");

extern "C" {static PyObject *meth_QGLWidget_destroy(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_destroy(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        bool a0 = 1;
        bool a1 = 1;
        sipQGLWidget *sipCpp;

        static const char *sipKwdList[] = {
            sipName_destroyWindow,
            sipName_destroySubWindows,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "B|bb", &sipSelf, sipType_QGLWidget, &sipCpp, &a0, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_destroy(a0,a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_destroy, doc_QGLWidget_destroy);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_focusNextPrevChild, "focusNextPrevChild(self, bool) -> bool");

extern "C" {static PyObject *meth_QGLWidget_focusNextPrevChild(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_focusNextPrevChild(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        bool a0;
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "Bb", &sipSelf, sipType_QGLWidget, &sipCpp, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtectVirt_focusNextPrevChild(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_focusNextPrevChild, doc_QGLWidget_focusNextPrevChild);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_focusNextChild, "focusNextChild(self) -> bool");

extern "C" {static PyObject *meth_QGLWidget_focusNextChild(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_focusNextChild(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QGLWidget, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_focusNextChild();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_focusNextChild, doc_QGLWidget_focusNextChild);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_focusPreviousChild, "focusPreviousChild(self) -> bool");

extern "C" {static PyObject *meth_QGLWidget_focusPreviousChild(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_focusPreviousChild(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QGLWidget, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_focusPreviousChild();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_focusPreviousChild, doc_QGLWidget_focusPreviousChild);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_enabledChange, "enabledChange(self, bool)");

extern "C" {static PyObject *meth_QGLWidget_enabledChange(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_enabledChange(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        bool a0;
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "Bb", &sipSelf, sipType_QGLWidget, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_enabledChange(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_enabledChange, doc_QGLWidget_enabledChange);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_paletteChange, "paletteChange(self, QPalette)");

extern "C" {static PyObject *meth_QGLWidget_paletteChange(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_paletteChange(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        const  ::QPalette* a0;
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QPalette, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_paletteChange(sipSelfWasArg,*a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_paletteChange, doc_QGLWidget_paletteChange);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_fontChange, "fontChange(self, QFont)");

extern "C" {static PyObject *meth_QGLWidget_fontChange(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_fontChange(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        const  ::QFont* a0;
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QFont, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_fontChange(sipSelfWasArg,*a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_fontChange, doc_QGLWidget_fontChange);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_windowActivationChange, "windowActivationChange(self, bool)");

extern "C" {static PyObject *meth_QGLWidget_windowActivationChange(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_windowActivationChange(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        bool a0;
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "Bb", &sipSelf, sipType_QGLWidget, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_windowActivationChange(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_windowActivationChange, doc_QGLWidget_windowActivationChange);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_languageChange, "languageChange(self)");

extern "C" {static PyObject *meth_QGLWidget_languageChange(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_languageChange(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QGLWidget, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_languageChange(sipSelfWasArg);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_languageChange, doc_QGLWidget_languageChange);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_qglColor, "qglColor(self, Union[QColor, Qt.GlobalColor])");

extern "C" {static PyObject *meth_QGLWidget_qglColor(PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_qglColor(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QColor* a0;
        int a0State = 0;
        const  ::QGLWidget *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QColor, &a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->qglColor(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::QColor *>(a0),sipType_QColor,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_qglColor, doc_QGLWidget_qglColor);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_qglClearColor, "qglClearColor(self, Union[QColor, Qt.GlobalColor])");

extern "C" {static PyObject *meth_QGLWidget_qglClearColor(PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_qglClearColor(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QColor* a0;
        int a0State = 0;
        const  ::QGLWidget *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QColor, &a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->qglClearColor(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::QColor *>(a0),sipType_QColor,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_qglClearColor, doc_QGLWidget_qglClearColor);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_isValid, "isValid(self) -> bool");

extern "C" {static PyObject *meth_QGLWidget_isValid(PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_isValid(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLWidget *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLWidget, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isValid();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_isValid, doc_QGLWidget_isValid);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_isSharing, "isSharing(self) -> bool");

extern "C" {static PyObject *meth_QGLWidget_isSharing(PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_isSharing(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLWidget *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLWidget, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isSharing();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_isSharing, doc_QGLWidget_isSharing);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_makeCurrent, "makeCurrent(self)");

extern "C" {static PyObject *meth_QGLWidget_makeCurrent(PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_makeCurrent(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLWidget *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLWidget, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->makeCurrent();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_makeCurrent, doc_QGLWidget_makeCurrent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_doneCurrent, "doneCurrent(self)");

extern "C" {static PyObject *meth_QGLWidget_doneCurrent(PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_doneCurrent(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLWidget *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLWidget, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->doneCurrent();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_doneCurrent, doc_QGLWidget_doneCurrent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_doubleBuffer, "doubleBuffer(self) -> bool");

extern "C" {static PyObject *meth_QGLWidget_doubleBuffer(PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_doubleBuffer(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLWidget *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLWidget, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->doubleBuffer();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_doubleBuffer, doc_QGLWidget_doubleBuffer);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_swapBuffers, "swapBuffers(self)");

extern "C" {static PyObject *meth_QGLWidget_swapBuffers(PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_swapBuffers(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLWidget *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLWidget, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->swapBuffers();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_swapBuffers, doc_QGLWidget_swapBuffers);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_format, "format(self) -> QGLFormat");

extern "C" {static PyObject *meth_QGLWidget_format(PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_format(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLWidget *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLWidget, &sipCpp))
        {
             ::QGLFormat*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QGLFormat(sipCpp->format());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QGLFormat,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_format, doc_QGLWidget_format);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_setFormat, "setFormat(self, QGLFormat)");

extern "C" {static PyObject *meth_QGLWidget_setFormat(PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_setFormat(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFormat* a0;
         ::QGLWidget *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QGLFormat, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setFormat(*a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_setFormat, doc_QGLWidget_setFormat);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_context, "context(self) -> QGLContext");

extern "C" {static PyObject *meth_QGLWidget_context(PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_context(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLWidget *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLWidget, &sipCpp))
        {
            const  ::QGLContext*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->context();
            Py_END_ALLOW_THREADS

            return sipConvertFromType(const_cast< ::QGLContext *>(sipRes),sipType_QGLContext,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_context, doc_QGLWidget_context);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_setContext, "setContext(self, QGLContext, shareContext: QGLContext = None, deleteOldContext: bool = True)");

extern "C" {static PyObject *meth_QGLWidget_setContext(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_setContext(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLContext* a0;
        const  ::QGLContext* a1 = 0;
        bool a2 = 1;
         ::QGLWidget *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            sipName_shareContext,
            sipName_deleteOldContext,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ:|J8b", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QGLContext, &a0, sipType_QGLContext, &a1, &a2))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setContext(a0,a1,a2);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_setContext, doc_QGLWidget_setContext);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_renderPixmap, "renderPixmap(self, width: int = 0, height: int = 0, useContext: bool = False) -> QPixmap");

extern "C" {static PyObject *meth_QGLWidget_renderPixmap(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_renderPixmap(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        int a0 = 0;
        int a1 = 0;
        bool a2 = 0;
         ::QGLWidget *sipCpp;

        static const char *sipKwdList[] = {
            sipName_width,
            sipName_height,
            sipName_useContext,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "B|iib", &sipSelf, sipType_QGLWidget, &sipCpp, &a0, &a1, &a2))
        {
             ::QPixmap*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QPixmap(sipCpp->renderPixmap(a0,a1,a2));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QPixmap,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_renderPixmap, doc_QGLWidget_renderPixmap);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_grabFrameBuffer, "grabFrameBuffer(self, withAlpha: bool = False) -> QImage");

extern "C" {static PyObject *meth_QGLWidget_grabFrameBuffer(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_grabFrameBuffer(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        bool a0 = 0;
         ::QGLWidget *sipCpp;

        static const char *sipKwdList[] = {
            sipName_withAlpha,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "B|b", &sipSelf, sipType_QGLWidget, &sipCpp, &a0))
        {
             ::QImage*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QImage(sipCpp->grabFrameBuffer(a0));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QImage,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_grabFrameBuffer, doc_QGLWidget_grabFrameBuffer);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_makeOverlayCurrent, "makeOverlayCurrent(self)");

extern "C" {static PyObject *meth_QGLWidget_makeOverlayCurrent(PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_makeOverlayCurrent(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLWidget *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLWidget, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->makeOverlayCurrent();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_makeOverlayCurrent, doc_QGLWidget_makeOverlayCurrent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_overlayContext, "overlayContext(self) -> QGLContext");

extern "C" {static PyObject *meth_QGLWidget_overlayContext(PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_overlayContext(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLWidget *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLWidget, &sipCpp))
        {
            const  ::QGLContext*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->overlayContext();
            Py_END_ALLOW_THREADS

            return sipConvertFromType(const_cast< ::QGLContext *>(sipRes),sipType_QGLContext,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_overlayContext, doc_QGLWidget_overlayContext);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_convertToGLFormat, "convertToGLFormat(QImage) -> QImage");

extern "C" {static PyObject *meth_QGLWidget_convertToGLFormat(PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_convertToGLFormat(PyObject *, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QImage* a0;

        if (sipParseArgs(&sipParseErr, sipArgs, "J9", sipType_QImage, &a0))
        {
             ::QImage*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QImage( ::QGLWidget::convertToGLFormat(*a0));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QImage,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_convertToGLFormat, doc_QGLWidget_convertToGLFormat);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_setMouseTracking, "setMouseTracking(self, bool)");

extern "C" {static PyObject *meth_QGLWidget_setMouseTracking(PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_setMouseTracking(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        bool a0;
         ::QGLWidget *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bb", &sipSelf, sipType_QGLWidget, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setMouseTracking(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_setMouseTracking, doc_QGLWidget_setMouseTracking);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_colormap, "colormap(self) -> QGLColormap");

extern "C" {static PyObject *meth_QGLWidget_colormap(PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_colormap(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLWidget *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLWidget, &sipCpp))
        {
             ::QGLColormap*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QGLColormap(sipCpp->colormap());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QGLColormap,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_colormap, doc_QGLWidget_colormap);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_setColormap, "setColormap(self, QGLColormap)");

extern "C" {static PyObject *meth_QGLWidget_setColormap(PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_setColormap(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLColormap* a0;
         ::QGLWidget *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QGLColormap, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setColormap(*a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_setColormap, doc_QGLWidget_setColormap);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_renderText, "renderText(self, int, int, str, font: QFont = QFont(), listBase: int = 2000)\n"
"renderText(self, float, float, float, str, font: QFont = QFont(), listBase: int = 2000)");

extern "C" {static PyObject *meth_QGLWidget_renderText(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_renderText(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        int a1;
        const  ::QString* a2;
        int a2State = 0;
        const  ::QFont& a3def = QFont();
        const  ::QFont* a3 = &a3def;
        int a4 = 2000;
         ::QGLWidget *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            NULL,
            sipName_font,
            sipName_listBase,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BiiJ1|J9i", &sipSelf, sipType_QGLWidget, &sipCpp, &a0, &a1, sipType_QString,&a2, &a2State, sipType_QFont, &a3, &a4))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->renderText(a0,a1,*a2,*a3,a4);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::QString *>(a2),sipType_QString,a2State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        double a0;
        double a1;
        double a2;
        const  ::QString* a3;
        int a3State = 0;
        const  ::QFont& a4def = QFont();
        const  ::QFont* a4 = &a4def;
        int a5 = 2000;
         ::QGLWidget *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            NULL,
            NULL,
            sipName_font,
            sipName_listBase,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BdddJ1|J9i", &sipSelf, sipType_QGLWidget, &sipCpp, &a0, &a1, &a2, sipType_QString,&a3, &a3State, sipType_QFont, &a4, &a5))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->renderText(a0,a1,a2,*a3,*a4,a5);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::QString *>(a3),sipType_QString,a3State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_renderText, doc_QGLWidget_renderText);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_paintEngine, "paintEngine(self) -> QPaintEngine");

extern "C" {static PyObject *meth_QGLWidget_paintEngine(PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_paintEngine(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        const  ::QGLWidget *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLWidget, &sipCpp))
        {
             ::QPaintEngine*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp-> ::QGLWidget::paintEngine() : sipCpp->paintEngine());
            Py_END_ALLOW_THREADS

            return sipConvertFromType(sipRes,sipType_QPaintEngine,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_paintEngine, doc_QGLWidget_paintEngine);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_bindTexture, "bindTexture(self, QImage, target: int = GL_TEXTURE_2D, format: int = GL_RGBA) -> int\n"
"bindTexture(self, QPixmap, target: int = GL_TEXTURE_2D, format: int = GL_RGBA) -> int\n"
"bindTexture(self, str) -> int\n"
"bindTexture(self, QImage, int, int, QGLContext.BindOptions) -> int\n"
"bindTexture(self, QPixmap, int, int, QGLContext.BindOptions) -> int");

extern "C" {static PyObject *meth_QGLWidget_bindTexture(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_bindTexture(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QImage* a0;
         ::GLenum a1 = GL_TEXTURE_2D;
         ::GLint a2 = GL_RGBA;
         ::QGLWidget *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            sipName_target,
            sipName_format,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ9|ui", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QImage, &a0, &a1, &a2))
        {
             ::GLuint sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->bindTexture(*a0,a1,a2);
            Py_END_ALLOW_THREADS

            return PyLong_FromUnsignedLong(sipRes);
        }
    }

    {
        const  ::QPixmap* a0;
         ::GLenum a1 = GL_TEXTURE_2D;
         ::GLint a2 = GL_RGBA;
         ::QGLWidget *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            sipName_target,
            sipName_format,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ9|ui", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QPixmap, &a0, &a1, &a2))
        {
             ::GLuint sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->bindTexture(*a0,a1,a2);
            Py_END_ALLOW_THREADS

            return PyLong_FromUnsignedLong(sipRes);
        }
    }

    {
        const  ::QString* a0;
        int a0State = 0;
         ::QGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ1", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QString,&a0, &a0State))
        {
             ::GLuint sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->bindTexture(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);

            return PyLong_FromUnsignedLong(sipRes);
        }
    }

    {
        const  ::QImage* a0;
         ::GLenum a1;
         ::GLint a2;
         ::QGLContext::BindOptions* a3;
        int a3State = 0;
         ::QGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9uiJ1", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QImage, &a0, &a1, &a2, sipType_QGLContext_BindOptions, &a3, &a3State))
        {
             ::GLuint sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->bindTexture(*a0,a1,a2,*a3);
            Py_END_ALLOW_THREADS
            sipReleaseType(a3,sipType_QGLContext_BindOptions,a3State);

            return PyLong_FromUnsignedLong(sipRes);
        }
    }

    {
        const  ::QPixmap* a0;
         ::GLenum a1;
         ::GLint a2;
         ::QGLContext::BindOptions* a3;
        int a3State = 0;
         ::QGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9uiJ1", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QPixmap, &a0, &a1, &a2, sipType_QGLContext_BindOptions, &a3, &a3State))
        {
             ::GLuint sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->bindTexture(*a0,a1,a2,*a3);
            Py_END_ALLOW_THREADS
            sipReleaseType(a3,sipType_QGLContext_BindOptions,a3State);

            return PyLong_FromUnsignedLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_bindTexture, doc_QGLWidget_bindTexture);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_drawTexture, "drawTexture(self, QRectF, int, textureTarget: int = GL_TEXTURE_2D)\n"
"drawTexture(self, Union[QPointF, QPoint], int, textureTarget: int = GL_TEXTURE_2D)");

extern "C" {static PyObject *meth_QGLWidget_drawTexture(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_drawTexture(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QRectF* a0;
         ::GLuint a1;
         ::GLenum a2 = GL_TEXTURE_2D;
         ::QGLWidget *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_textureTarget,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ9u|u", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QRectF, &a0, &a1, &a2))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->drawTexture(*a0,a1,a2);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const  ::QPointF* a0;
        int a0State = 0;
         ::GLuint a1;
         ::GLenum a2 = GL_TEXTURE_2D;
         ::QGLWidget *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_textureTarget,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ1u|u", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QPointF, &a0, &a0State, &a1, &a2))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->drawTexture(*a0,a1,a2);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::QPointF *>(a0),sipType_QPointF,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_drawTexture, doc_QGLWidget_drawTexture);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_deleteTexture, "deleteTexture(self, int)");

extern "C" {static PyObject *meth_QGLWidget_deleteTexture(PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_deleteTexture(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::GLuint a0;
         ::QGLWidget *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QGLWidget, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->deleteTexture(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_deleteTexture, doc_QGLWidget_deleteTexture);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_updateGL, "updateGL(self)");

extern "C" {static PyObject *meth_QGLWidget_updateGL(PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_updateGL(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QGLWidget *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLWidget, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp-> ::QGLWidget::updateGL() : sipCpp->updateGL());
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_updateGL, doc_QGLWidget_updateGL);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_updateOverlayGL, "updateOverlayGL(self)");

extern "C" {static PyObject *meth_QGLWidget_updateOverlayGL(PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_updateOverlayGL(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QGLWidget *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLWidget, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp-> ::QGLWidget::updateOverlayGL() : sipCpp->updateOverlayGL());
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_updateOverlayGL, doc_QGLWidget_updateOverlayGL);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_event, "event(self, QEvent) -> bool");

extern "C" {static PyObject *meth_QGLWidget_event(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_event(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QEvent* a0;
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QEvent, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtectVirt_event(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_event, doc_QGLWidget_event);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_initializeGL, "initializeGL(self)");

extern "C" {static PyObject *meth_QGLWidget_initializeGL(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_initializeGL(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QGLWidget, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_initializeGL(sipSelfWasArg);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_initializeGL, doc_QGLWidget_initializeGL);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_resizeGL, "resizeGL(self, int, int)");

extern "C" {static PyObject *meth_QGLWidget_resizeGL(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_resizeGL(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        int a0;
        int a1;
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "Bii", &sipSelf, sipType_QGLWidget, &sipCpp, &a0, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_resizeGL(sipSelfWasArg,a0,a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_resizeGL, doc_QGLWidget_resizeGL);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_paintGL, "paintGL(self)");

extern "C" {static PyObject *meth_QGLWidget_paintGL(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_paintGL(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QGLWidget, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_paintGL(sipSelfWasArg);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_paintGL, doc_QGLWidget_paintGL);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_initializeOverlayGL, "initializeOverlayGL(self)");

extern "C" {static PyObject *meth_QGLWidget_initializeOverlayGL(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_initializeOverlayGL(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QGLWidget, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_initializeOverlayGL(sipSelfWasArg);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_initializeOverlayGL, doc_QGLWidget_initializeOverlayGL);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_resizeOverlayGL, "resizeOverlayGL(self, int, int)");

extern "C" {static PyObject *meth_QGLWidget_resizeOverlayGL(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_resizeOverlayGL(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        int a0;
        int a1;
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "Bii", &sipSelf, sipType_QGLWidget, &sipCpp, &a0, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_resizeOverlayGL(sipSelfWasArg,a0,a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_resizeOverlayGL, doc_QGLWidget_resizeOverlayGL);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_paintOverlayGL, "paintOverlayGL(self)");

extern "C" {static PyObject *meth_QGLWidget_paintOverlayGL(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_paintOverlayGL(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QGLWidget, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_paintOverlayGL(sipSelfWasArg);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_paintOverlayGL, doc_QGLWidget_paintOverlayGL);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_setAutoBufferSwap, "setAutoBufferSwap(self, bool)");

extern "C" {static PyObject *meth_QGLWidget_setAutoBufferSwap(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_setAutoBufferSwap(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        bool a0;
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "Bb", &sipSelf, sipType_QGLWidget, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_setAutoBufferSwap(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_setAutoBufferSwap, doc_QGLWidget_setAutoBufferSwap);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_autoBufferSwap, "autoBufferSwap(self) -> bool");

extern "C" {static PyObject *meth_QGLWidget_autoBufferSwap(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_autoBufferSwap(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QGLWidget, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_autoBufferSwap();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_autoBufferSwap, doc_QGLWidget_autoBufferSwap);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_paintEvent, "paintEvent(self, QPaintEvent)");

extern "C" {static PyObject *meth_QGLWidget_paintEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_paintEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QPaintEvent* a0;
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QPaintEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_paintEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_paintEvent, doc_QGLWidget_paintEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_resizeEvent, "resizeEvent(self, QResizeEvent)");

extern "C" {static PyObject *meth_QGLWidget_resizeEvent(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_resizeEvent(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QResizeEvent* a0;
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ8", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QResizeEvent, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_resizeEvent(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_resizeEvent, doc_QGLWidget_resizeEvent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_glInit, "glInit(self)");

extern "C" {static PyObject *meth_QGLWidget_glInit(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_glInit(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QGLWidget, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_glInit(sipSelfWasArg);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_glInit, doc_QGLWidget_glInit);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_glDraw, "glDraw(self)");

extern "C" {static PyObject *meth_QGLWidget_glDraw(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_glDraw(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        sipQGLWidget *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QGLWidget, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtectVirt_glDraw(sipSelfWasArg);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_glDraw, doc_QGLWidget_glDraw);

    return NULL;
}


PyDoc_STRVAR(doc_QGLWidget_fontDisplayListBase, "fontDisplayListBase(self, QFont, listBase: int = 2000) -> int");

extern "C" {static PyObject *meth_QGLWidget_fontDisplayListBase(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLWidget_fontDisplayListBase(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QFont* a0;
        int a1 = 2000;
        sipQGLWidget *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            sipName_listBase,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ9|i", &sipSelf, sipType_QGLWidget, &sipCpp, sipType_QFont, &a0, &a1))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_fontDisplayListBase(*a0,a1);
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLWidget, sipName_fontDisplayListBase, doc_QGLWidget_fontDisplayListBase);

    return NULL;
}


/* Cast a pointer to a type somewhere in its inheritance hierarchy. */
extern "C" {static void *cast_QGLWidget(void *, const sipTypeDef *);}
static void *cast_QGLWidget(void *sipCppV, const sipTypeDef *targetType)
{
     ::QGLWidget *sipCpp = reinterpret_cast< ::QGLWidget *>(sipCppV);

    if (targetType == sipType_QWidget)
        return static_cast< ::QWidget *>(sipCpp);

    if (targetType == sipType_QObject)
        return static_cast< ::QObject *>(sipCpp);

    if (targetType == sipType_QPaintDevice)
        return static_cast< ::QPaintDevice *>(sipCpp);

    return sipCppV;
}


/* Call the instance's destructor. */
extern "C" {static void release_QGLWidget(void *, int);}
static void release_QGLWidget(void *sipCppV, int)
{
     ::QGLWidget *sipCpp = reinterpret_cast< ::QGLWidget *>(sipCppV);

    Py_BEGIN_ALLOW_THREADS

    if (QThread::currentThread() == sipCpp->thread())
        delete sipCpp;
    else
        sipCpp->deleteLater();

    Py_END_ALLOW_THREADS
}


extern "C" {static void dealloc_QGLWidget(sipSimpleWrapper *);}
static void dealloc_QGLWidget(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerivedClass(sipSelf))
        reinterpret_cast<sipQGLWidget *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsOwnedByPython(sipSelf))
    {
        release_QGLWidget(sipGetAddress(sipSelf), sipIsDerivedClass(sipSelf));
    }
}


extern "C" {static void *init_type_QGLWidget(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QGLWidget(sipSimpleWrapper *sipSelf, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **sipOwner, PyObject **sipParseErr)
{
    sipQGLWidget *sipCpp = 0;

    {
         ::QWidget* a0 = 0;
        const  ::QGLWidget* a1 = 0;
         ::Qt::WindowFlags a2def = 0;
         ::Qt::WindowFlags* a2 = &a2def;
        int a2State = 0;

        static const char *sipKwdList[] = {
            sipName_parent,
            sipName_shareWidget,
            sipName_flags,
        };

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "|JHJ8J1", sipType_QWidget, &a0, sipOwner, sipType_QGLWidget, &a1, sipType_Qt_WindowFlags, &a2, &a2State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQGLWidget(a0,a1,*a2);
            Py_END_ALLOW_THREADS
            sipReleaseType(a2,sipType_Qt_WindowFlags,a2State);

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    {
         ::QGLContext* a0;
         ::QWidget* a1 = 0;
        const  ::QGLWidget* a2 = 0;
         ::Qt::WindowFlags a3def = 0;
         ::Qt::WindowFlags* a3 = &a3def;
        int a3State = 0;

        static const char *sipKwdList[] = {
            NULL,
            sipName_parent,
            sipName_shareWidget,
            sipName_flags,
        };

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "J:|JHJ8J1", sipType_QGLContext, &a0, sipType_QWidget, &a1, sipOwner, sipType_QGLWidget, &a2, sipType_Qt_WindowFlags, &a3, &a3State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQGLWidget(a0,a1,a2,*a3);
            Py_END_ALLOW_THREADS
            sipReleaseType(a3,sipType_Qt_WindowFlags,a3State);

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    {
        const  ::QGLFormat* a0;
         ::QWidget* a1 = 0;
        const  ::QGLWidget* a2 = 0;
         ::Qt::WindowFlags a3def = 0;
         ::Qt::WindowFlags* a3 = &a3def;
        int a3State = 0;

        static const char *sipKwdList[] = {
            NULL,
            sipName_parent,
            sipName_shareWidget,
            sipName_flags,
        };

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "J9|JHJ8J1", sipType_QGLFormat, &a0, sipType_QWidget, &a1, sipOwner, sipType_QGLWidget, &a2, sipType_Qt_WindowFlags, &a3, &a3State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQGLWidget(*a0,a1,a2,*a3);
            Py_END_ALLOW_THREADS
            sipReleaseType(a3,sipType_Qt_WindowFlags,a3State);

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's super-types. */
static sipEncodedTypeDef supers_QGLWidget[] = {{40, 1, 1}};


static PyMethodDef methods_QGLWidget[] = {
    {SIP_MLNAME_CAST(sipName_actionEvent), (PyCFunction)meth_QGLWidget_actionEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_autoBufferSwap), (PyCFunction)meth_QGLWidget_autoBufferSwap, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLWidget_autoBufferSwap)},
    {SIP_MLNAME_CAST(sipName_bindTexture), (PyCFunction)meth_QGLWidget_bindTexture, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLWidget_bindTexture)},
    {SIP_MLNAME_CAST(sipName_changeEvent), (PyCFunction)meth_QGLWidget_changeEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_childEvent), (PyCFunction)meth_QGLWidget_childEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_closeEvent), (PyCFunction)meth_QGLWidget_closeEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_colormap), meth_QGLWidget_colormap, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLWidget_colormap)},
    {SIP_MLNAME_CAST(sipName_connectNotify), (PyCFunction)meth_QGLWidget_connectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_context), meth_QGLWidget_context, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLWidget_context)},
    {SIP_MLNAME_CAST(sipName_contextMenuEvent), (PyCFunction)meth_QGLWidget_contextMenuEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_convertToGLFormat), meth_QGLWidget_convertToGLFormat, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLWidget_convertToGLFormat)},
    {SIP_MLNAME_CAST(sipName_create), (PyCFunction)meth_QGLWidget_create, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_customEvent), (PyCFunction)meth_QGLWidget_customEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_deleteTexture), meth_QGLWidget_deleteTexture, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLWidget_deleteTexture)},
    {SIP_MLNAME_CAST(sipName_destroy), (PyCFunction)meth_QGLWidget_destroy, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_disconnectNotify), (PyCFunction)meth_QGLWidget_disconnectNotify, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_doneCurrent), meth_QGLWidget_doneCurrent, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLWidget_doneCurrent)},
    {SIP_MLNAME_CAST(sipName_doubleBuffer), meth_QGLWidget_doubleBuffer, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLWidget_doubleBuffer)},
    {SIP_MLNAME_CAST(sipName_dragEnterEvent), (PyCFunction)meth_QGLWidget_dragEnterEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_dragLeaveEvent), (PyCFunction)meth_QGLWidget_dragLeaveEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_dragMoveEvent), (PyCFunction)meth_QGLWidget_dragMoveEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_drawTexture), (PyCFunction)meth_QGLWidget_drawTexture, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLWidget_drawTexture)},
    {SIP_MLNAME_CAST(sipName_dropEvent), (PyCFunction)meth_QGLWidget_dropEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_enabledChange), (PyCFunction)meth_QGLWidget_enabledChange, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_enterEvent), (PyCFunction)meth_QGLWidget_enterEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_event), (PyCFunction)meth_QGLWidget_event, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLWidget_event)},
    {SIP_MLNAME_CAST(sipName_focusInEvent), (PyCFunction)meth_QGLWidget_focusInEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_focusNextChild), (PyCFunction)meth_QGLWidget_focusNextChild, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_focusNextPrevChild), (PyCFunction)meth_QGLWidget_focusNextPrevChild, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_focusOutEvent), (PyCFunction)meth_QGLWidget_focusOutEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_focusPreviousChild), (PyCFunction)meth_QGLWidget_focusPreviousChild, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_fontChange), (PyCFunction)meth_QGLWidget_fontChange, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_fontDisplayListBase), (PyCFunction)meth_QGLWidget_fontDisplayListBase, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLWidget_fontDisplayListBase)},
    {SIP_MLNAME_CAST(sipName_format), meth_QGLWidget_format, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLWidget_format)},
    {SIP_MLNAME_CAST(sipName_glDraw), (PyCFunction)meth_QGLWidget_glDraw, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLWidget_glDraw)},
    {SIP_MLNAME_CAST(sipName_glInit), (PyCFunction)meth_QGLWidget_glInit, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLWidget_glInit)},
    {SIP_MLNAME_CAST(sipName_grabFrameBuffer), (PyCFunction)meth_QGLWidget_grabFrameBuffer, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLWidget_grabFrameBuffer)},
    {SIP_MLNAME_CAST(sipName_hideEvent), (PyCFunction)meth_QGLWidget_hideEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_initializeGL), (PyCFunction)meth_QGLWidget_initializeGL, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLWidget_initializeGL)},
    {SIP_MLNAME_CAST(sipName_initializeOverlayGL), (PyCFunction)meth_QGLWidget_initializeOverlayGL, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLWidget_initializeOverlayGL)},
    {SIP_MLNAME_CAST(sipName_inputMethodEvent), (PyCFunction)meth_QGLWidget_inputMethodEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_isSharing), meth_QGLWidget_isSharing, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLWidget_isSharing)},
    {SIP_MLNAME_CAST(sipName_isValid), meth_QGLWidget_isValid, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLWidget_isValid)},
    {SIP_MLNAME_CAST(sipName_keyPressEvent), (PyCFunction)meth_QGLWidget_keyPressEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_keyReleaseEvent), (PyCFunction)meth_QGLWidget_keyReleaseEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_languageChange), (PyCFunction)meth_QGLWidget_languageChange, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_leaveEvent), (PyCFunction)meth_QGLWidget_leaveEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_makeCurrent), meth_QGLWidget_makeCurrent, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLWidget_makeCurrent)},
    {SIP_MLNAME_CAST(sipName_makeOverlayCurrent), meth_QGLWidget_makeOverlayCurrent, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLWidget_makeOverlayCurrent)},
    {SIP_MLNAME_CAST(sipName_metric), (PyCFunction)meth_QGLWidget_metric, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_mouseDoubleClickEvent), (PyCFunction)meth_QGLWidget_mouseDoubleClickEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_mouseMoveEvent), (PyCFunction)meth_QGLWidget_mouseMoveEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_mousePressEvent), (PyCFunction)meth_QGLWidget_mousePressEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_mouseReleaseEvent), (PyCFunction)meth_QGLWidget_mouseReleaseEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_moveEvent), (PyCFunction)meth_QGLWidget_moveEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_overlayContext), meth_QGLWidget_overlayContext, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLWidget_overlayContext)},
    {SIP_MLNAME_CAST(sipName_paintEngine), meth_QGLWidget_paintEngine, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLWidget_paintEngine)},
    {SIP_MLNAME_CAST(sipName_paintEvent), (PyCFunction)meth_QGLWidget_paintEvent, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLWidget_paintEvent)},
    {SIP_MLNAME_CAST(sipName_paintGL), (PyCFunction)meth_QGLWidget_paintGL, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLWidget_paintGL)},
    {SIP_MLNAME_CAST(sipName_paintOverlayGL), (PyCFunction)meth_QGLWidget_paintOverlayGL, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLWidget_paintOverlayGL)},
    {SIP_MLNAME_CAST(sipName_paletteChange), (PyCFunction)meth_QGLWidget_paletteChange, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_qglClearColor), meth_QGLWidget_qglClearColor, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLWidget_qglClearColor)},
    {SIP_MLNAME_CAST(sipName_qglColor), meth_QGLWidget_qglColor, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLWidget_qglColor)},
    {SIP_MLNAME_CAST(sipName_receivers), (PyCFunction)meth_QGLWidget_receivers, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_renderPixmap), (PyCFunction)meth_QGLWidget_renderPixmap, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLWidget_renderPixmap)},
    {SIP_MLNAME_CAST(sipName_renderText), (PyCFunction)meth_QGLWidget_renderText, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLWidget_renderText)},
    {SIP_MLNAME_CAST(sipName_resetInputContext), (PyCFunction)meth_QGLWidget_resetInputContext, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_resizeEvent), (PyCFunction)meth_QGLWidget_resizeEvent, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLWidget_resizeEvent)},
    {SIP_MLNAME_CAST(sipName_resizeGL), (PyCFunction)meth_QGLWidget_resizeGL, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLWidget_resizeGL)},
    {SIP_MLNAME_CAST(sipName_resizeOverlayGL), (PyCFunction)meth_QGLWidget_resizeOverlayGL, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLWidget_resizeOverlayGL)},
    {SIP_MLNAME_CAST(sipName_sender), (PyCFunction)meth_QGLWidget_sender, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_senderSignalIndex), (PyCFunction)meth_QGLWidget_senderSignalIndex, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_setAutoBufferSwap), (PyCFunction)meth_QGLWidget_setAutoBufferSwap, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLWidget_setAutoBufferSwap)},
    {SIP_MLNAME_CAST(sipName_setColormap), meth_QGLWidget_setColormap, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLWidget_setColormap)},
    {SIP_MLNAME_CAST(sipName_setContext), (PyCFunction)meth_QGLWidget_setContext, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLWidget_setContext)},
    {SIP_MLNAME_CAST(sipName_setFormat), meth_QGLWidget_setFormat, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLWidget_setFormat)},
    {SIP_MLNAME_CAST(sipName_setMouseTracking), meth_QGLWidget_setMouseTracking, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLWidget_setMouseTracking)},
    {SIP_MLNAME_CAST(sipName_showEvent), (PyCFunction)meth_QGLWidget_showEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_swapBuffers), meth_QGLWidget_swapBuffers, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLWidget_swapBuffers)},
    {SIP_MLNAME_CAST(sipName_tabletEvent), (PyCFunction)meth_QGLWidget_tabletEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_timerEvent), (PyCFunction)meth_QGLWidget_timerEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_updateGL), meth_QGLWidget_updateGL, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLWidget_updateGL)},
    {SIP_MLNAME_CAST(sipName_updateMicroFocus), (PyCFunction)meth_QGLWidget_updateMicroFocus, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_updateOverlayGL), meth_QGLWidget_updateOverlayGL, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLWidget_updateOverlayGL)},
    {SIP_MLNAME_CAST(sipName_wheelEvent), (PyCFunction)meth_QGLWidget_wheelEvent, METH_VARARGS|METH_KEYWORDS, NULL},
    {SIP_MLNAME_CAST(sipName_windowActivationChange), (PyCFunction)meth_QGLWidget_windowActivationChange, METH_VARARGS|METH_KEYWORDS, NULL}
};

PyDoc_STRVAR(doc_QGLWidget, "\1QGLWidget(parent: QWidget = None, shareWidget: QGLWidget = None, flags: Union[Qt.WindowFlags, Qt.WindowType] = 0)\n"
"QGLWidget(QGLContext, parent: QWidget = None, shareWidget: QGLWidget = None, flags: Union[Qt.WindowFlags, Qt.WindowType] = 0)\n"
"QGLWidget(QGLFormat, parent: QWidget = None, shareWidget: QGLWidget = None, flags: Union[Qt.WindowFlags, Qt.WindowType] = 0)");


static pyqt4ClassPluginDef plugin_QGLWidget = {
    & ::QGLWidget::staticMetaObject,
    0,
    0
};


sipClassTypeDef sipTypeDef_QtOpenGL_QGLWidget = {
    {
        -1,
        0,
        0,
        SIP_TYPE_SCC|SIP_TYPE_CLASS,
        sipNameNr_QGLWidget,
        {0},
        &plugin_QGLWidget
    },
    {
        sipNameNr_QGLWidget,
        {0, 0, 1},
        86, methods_QGLWidget,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QGLWidget,
    -1,
    -1,
    supers_QGLWidget,
    0,
    init_type_QGLWidget,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QGLWidget,
    0,
    0,
    0,
    release_QGLWidget,
    cast_QGLWidget,
    0,
    0,
    0,
    0,
    0,
    0
};

#line 225 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qgl.sip"
#include <qgl.h>
#line 15278 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

#line 225 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qgl.sip"
#include <qgl.h>
#line 15282 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"


extern "C" {static int slot_QGLContext_BindOptions___bool__(PyObject *);}
static int slot_QGLContext_BindOptions___bool__(PyObject *sipSelf)
{
     ::QGLContext::BindOptions *sipCpp = reinterpret_cast< ::QGLContext::BindOptions *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGLContext_BindOptions));

    if (!sipCpp)
        return -1;


    {
        {
            int sipRes = 0;

#line 381 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qglobal.sip"
#if QT_VERSION >= 0x050000
        sipRes = (sipCpp->operator QGLContext::BindOptions::Int() != 0);
#else
        sipRes = (sipCpp->operator int() != 0);
#endif
#line 15304 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

            return sipRes;
        }
    }

    return 0;
}


extern "C" {static PyObject *slot_QGLContext_BindOptions___ne__(PyObject *,PyObject *);}
static PyObject *slot_QGLContext_BindOptions___ne__(PyObject *sipSelf,PyObject *sipArg)
{
     ::QGLContext::BindOptions *sipCpp = reinterpret_cast< ::QGLContext::BindOptions *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGLContext_BindOptions));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const  ::QGLContext::BindOptions* a0;
        int a0State = 0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J1", sipType_QGLContext_BindOptions, &a0, &a0State))
        {
            bool sipRes = 0;

#line 372 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qglobal.sip"
#if QT_VERSION >= 0x050000
        sipRes = (sipCpp->operator QGLContext::BindOptions::Int() != a0->operator QGLContext::BindOptions::Int());
#else
        sipRes = (sipCpp->operator int() != a0->operator int());
#endif
#line 15338 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
            sipReleaseType(const_cast< ::QGLContext::BindOptions *>(a0),sipType_QGLContext_BindOptions,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtOpenGL, ne_slot, sipType_QGLContext_BindOptions, sipSelf, sipArg);
}


extern "C" {static PyObject *slot_QGLContext_BindOptions___eq__(PyObject *,PyObject *);}
static PyObject *slot_QGLContext_BindOptions___eq__(PyObject *sipSelf,PyObject *sipArg)
{
     ::QGLContext::BindOptions *sipCpp = reinterpret_cast< ::QGLContext::BindOptions *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGLContext_BindOptions));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const  ::QGLContext::BindOptions* a0;
        int a0State = 0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J1", sipType_QGLContext_BindOptions, &a0, &a0State))
        {
            bool sipRes = 0;

#line 363 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qglobal.sip"
#if QT_VERSION >= 0x050000
        sipRes = (sipCpp->operator QGLContext::BindOptions::Int() == a0->operator QGLContext::BindOptions::Int());
#else
        sipRes = (sipCpp->operator int() == a0->operator int());
#endif
#line 15378 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
            sipReleaseType(const_cast< ::QGLContext::BindOptions *>(a0),sipType_QGLContext_BindOptions,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtOpenGL, eq_slot, sipType_QGLContext_BindOptions, sipSelf, sipArg);
}


extern "C" {static PyObject *slot_QGLContext_BindOptions___ixor__(PyObject *,PyObject *);}
static PyObject *slot_QGLContext_BindOptions___ixor__(PyObject *sipSelf,PyObject *sipArg)
{
    if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QGLContext_BindOptions)))
    {
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    }

     ::QGLContext::BindOptions *sipCpp = reinterpret_cast< ::QGLContext::BindOptions *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGLContext_BindOptions));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        int a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1i", &a0))
        {
#line 357 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qglobal.sip"
        *sipCpp = QGLContext::BindOptions(*sipCpp ^ a0);
#line 15417 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

            Py_INCREF(sipSelf);
            return sipSelf;
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    PyErr_Clear();

    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}


extern "C" {static PyObject *slot_QGLContext_BindOptions___xor__(PyObject *,PyObject *);}
static PyObject *slot_QGLContext_BindOptions___xor__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLContext::BindOptions* a0;
        int a0State = 0;
        int a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J1i", sipType_QGLContext_BindOptions, &a0, &a0State, &a1))
        {
             ::QGLContext::BindOptions*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QGLContext::BindOptions((*a0 ^ a1));
            Py_END_ALLOW_THREADS
            sipReleaseType(a0,sipType_QGLContext_BindOptions,a0State);

            return sipConvertFromNewType(sipRes,sipType_QGLContext_BindOptions,NULL);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtOpenGL, xor_slot, NULL, sipArg0, sipArg1);
}


extern "C" {static PyObject *slot_QGLContext_BindOptions___ior__(PyObject *,PyObject *);}
static PyObject *slot_QGLContext_BindOptions___ior__(PyObject *sipSelf,PyObject *sipArg)
{
    if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QGLContext_BindOptions)))
    {
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    }

     ::QGLContext::BindOptions *sipCpp = reinterpret_cast< ::QGLContext::BindOptions *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGLContext_BindOptions));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        int a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1i", &a0))
        {
#line 351 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qglobal.sip"
        *sipCpp = QGLContext::BindOptions(*sipCpp | a0);
#line 15491 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

            Py_INCREF(sipSelf);
            return sipSelf;
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    PyErr_Clear();

    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}


extern "C" {static PyObject *slot_QGLContext_BindOptions___or__(PyObject *,PyObject *);}
static PyObject *slot_QGLContext_BindOptions___or__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLContext::BindOptions* a0;
        int a0State = 0;
        int a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J1i", sipType_QGLContext_BindOptions, &a0, &a0State, &a1))
        {
             ::QGLContext::BindOptions*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QGLContext::BindOptions((*a0 | a1));
            Py_END_ALLOW_THREADS
            sipReleaseType(a0,sipType_QGLContext_BindOptions,a0State);

            return sipConvertFromNewType(sipRes,sipType_QGLContext_BindOptions,NULL);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtOpenGL, or_slot, NULL, sipArg0, sipArg1);
}


extern "C" {static PyObject *slot_QGLContext_BindOptions___iand__(PyObject *,PyObject *);}
static PyObject *slot_QGLContext_BindOptions___iand__(PyObject *sipSelf,PyObject *sipArg)
{
    if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QGLContext_BindOptions)))
    {
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    }

     ::QGLContext::BindOptions *sipCpp = reinterpret_cast< ::QGLContext::BindOptions *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGLContext_BindOptions));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        int a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1i", &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp-> ::QGLContext::BindOptions::operator&=(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(sipSelf);
            return sipSelf;
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    PyErr_Clear();

    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}


extern "C" {static PyObject *slot_QGLContext_BindOptions___and__(PyObject *,PyObject *);}
static PyObject *slot_QGLContext_BindOptions___and__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLContext::BindOptions* a0;
        int a0State = 0;
        int a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J1i", sipType_QGLContext_BindOptions, &a0, &a0State, &a1))
        {
             ::QGLContext::BindOptions*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QGLContext::BindOptions((*a0 & a1));
            Py_END_ALLOW_THREADS
            sipReleaseType(a0,sipType_QGLContext_BindOptions,a0State);

            return sipConvertFromNewType(sipRes,sipType_QGLContext_BindOptions,NULL);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtOpenGL, and_slot, NULL, sipArg0, sipArg1);
}


extern "C" {static PyObject *slot_QGLContext_BindOptions___invert__(PyObject *);}
static PyObject *slot_QGLContext_BindOptions___invert__(PyObject *sipSelf)
{
     ::QGLContext::BindOptions *sipCpp = reinterpret_cast< ::QGLContext::BindOptions *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGLContext_BindOptions));

    if (!sipCpp)
        return 0;


    {
        {
             ::QGLContext::BindOptions*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QGLContext::BindOptions(~(*sipCpp));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QGLContext_BindOptions,NULL);
        }
    }

    return 0;
}


extern "C" {static PyObject *slot_QGLContext_BindOptions___int__(PyObject *);}
static PyObject *slot_QGLContext_BindOptions___int__(PyObject *sipSelf)
{
     ::QGLContext::BindOptions *sipCpp = reinterpret_cast< ::QGLContext::BindOptions *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGLContext_BindOptions));

    if (!sipCpp)
        return 0;


    {
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = *sipCpp;
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    return 0;
}


/* Call the instance's destructor. */
extern "C" {static void release_QGLContext_BindOptions(void *, int);}
static void release_QGLContext_BindOptions(void *sipCppV, int)
{
    Py_BEGIN_ALLOW_THREADS

    delete reinterpret_cast< ::QGLContext::BindOptions *>(sipCppV);

    Py_END_ALLOW_THREADS
}


extern "C" {static void assign_QGLContext_BindOptions(void *, SIP_SSIZE_T, void *);}
static void assign_QGLContext_BindOptions(void *sipDst, SIP_SSIZE_T sipDstIdx, void *sipSrc)
{
    reinterpret_cast< ::QGLContext::BindOptions *>(sipDst)[sipDstIdx] = *reinterpret_cast< ::QGLContext::BindOptions *>(sipSrc);
}


extern "C" {static void *array_QGLContext_BindOptions(SIP_SSIZE_T);}
static void *array_QGLContext_BindOptions(SIP_SSIZE_T sipNrElem)
{
    return new  ::QGLContext::BindOptions[sipNrElem];
}


extern "C" {static void *copy_QGLContext_BindOptions(const void *, SIP_SSIZE_T);}
static void *copy_QGLContext_BindOptions(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new  ::QGLContext::BindOptions(reinterpret_cast<const  ::QGLContext::BindOptions *>(sipSrc)[sipSrcIdx]);
}


extern "C" {static void dealloc_QGLContext_BindOptions(sipSimpleWrapper *);}
static void dealloc_QGLContext_BindOptions(sipSimpleWrapper *sipSelf)
{
    if (sipIsOwnedByPython(sipSelf))
    {
        release_QGLContext_BindOptions(sipGetAddress(sipSelf), 0);
    }
}


extern "C" {static void *init_type_QGLContext_BindOptions(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QGLContext_BindOptions(sipSimpleWrapper *, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
     ::QGLContext::BindOptions *sipCpp = 0;

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new  ::QGLContext::BindOptions();
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    {
        int a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "i", &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new  ::QGLContext::BindOptions(a0);
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    {
        const  ::QGLContext::BindOptions* a0;
        int a0State = 0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J1", sipType_QGLContext_BindOptions, &a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new  ::QGLContext::BindOptions(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::QGLContext::BindOptions *>(a0),sipType_QGLContext_BindOptions,a0State);

            return sipCpp;
        }
    }

    return NULL;
}


extern "C" {static int convertTo_QGLContext_BindOptions(PyObject *, void **, int *, PyObject *);}
static int convertTo_QGLContext_BindOptions(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
     ::QGLContext::BindOptions **sipCppPtr = reinterpret_cast< ::QGLContext::BindOptions **>(sipCppPtrV);

#line 390 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qglobal.sip"
// Allow an instance of the base enum whenever a QGLContext::BindOptions is expected.

if (sipIsErr == NULL)
    return (PyObject_TypeCheck(sipPy, sipTypeAsPyTypeObject(sipType_QGLContext_BindOption)) ||
            sipCanConvertToType(sipPy, sipType_QGLContext_BindOptions, SIP_NO_CONVERTORS));

if (PyObject_TypeCheck(sipPy, sipTypeAsPyTypeObject(sipType_QGLContext_BindOption)))
{
    *sipCppPtr = new QGLContext::BindOptions(int(SIPLong_AsLong(sipPy)));

    return sipGetState(sipTransferObj);
}

*sipCppPtr = reinterpret_cast<QGLContext::BindOptions *>(sipConvertToType(sipPy, sipType_QGLContext_BindOptions, sipTransferObj, SIP_NO_CONVERTORS, 0, sipIsErr));

return 0;
#line 15779 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
}


/* Define this type's Python slots. */
static sipPySlotDef slots_QGLContext_BindOptions[] = {
    {(void *)slot_QGLContext_BindOptions___bool__, bool_slot},
    {(void *)slot_QGLContext_BindOptions___ne__, ne_slot},
    {(void *)slot_QGLContext_BindOptions___eq__, eq_slot},
    {(void *)slot_QGLContext_BindOptions___ixor__, ixor_slot},
    {(void *)slot_QGLContext_BindOptions___xor__, xor_slot},
    {(void *)slot_QGLContext_BindOptions___ior__, ior_slot},
    {(void *)slot_QGLContext_BindOptions___or__, or_slot},
    {(void *)slot_QGLContext_BindOptions___iand__, iand_slot},
    {(void *)slot_QGLContext_BindOptions___and__, and_slot},
    {(void *)slot_QGLContext_BindOptions___invert__, invert_slot},
    {(void *)slot_QGLContext_BindOptions___int__, int_slot},
    {0, (sipPySlotType)0}
};

PyDoc_STRVAR(doc_QGLContext_BindOptions, "\1QGLContext.BindOptions()\n"
"QGLContext.BindOptions(Union[QGLContext.BindOptions, QGLContext.BindOption])\n"
"QGLContext.BindOptions(QGLContext.BindOptions)");


static pyqt4ClassPluginDef plugin_QGLContext_BindOptions = {
    0,
    1,
    0
};


sipClassTypeDef sipTypeDef_QtOpenGL_QGLContext_BindOptions = {
    {
        -1,
        0,
        0,
        SIP_TYPE_CLASS,
        sipNameNr_QGLContext__BindOptions,
        {0},
        &plugin_QGLContext_BindOptions
    },
    {
        sipNameNr_BindOptions,
        {8, 255, 0},
        0, 0,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QGLContext_BindOptions,
    sipNameNr_PyQt4_QtCore_pyqtWrapperType,
    sipNameNr_sip_simplewrapper,
    0,
    slots_QGLContext_BindOptions,
    init_type_QGLContext_BindOptions,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QGLContext_BindOptions,
    assign_QGLContext_BindOptions,
    array_QGLContext_BindOptions,
    copy_QGLContext_BindOptions,
    release_QGLContext_BindOptions,
    0,
    convertTo_QGLContext_BindOptions,
    0,
    0,
    0,
    0,
    0
};

#line 225 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qgl.sip"
#include <qgl.h>
#line 15865 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

#line 70 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qgl.sip"
#include <qgl.h>
#line 15869 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qpaintdevice.sip"
#include <qpaintdevice.h>
#line 15872 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qfont.sip"
#include <qfont.h>
#line 15875 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qcolor.sip"
#include <qcolor.h>
#line 15878 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 27 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qstring.sip"
#include <qstring.h>
#line 15881 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 159 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qrect.sip"
#include <qrect.h>
#line 15884 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 110 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qpoint.sip"
#include <qpoint.h>
#line 15887 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qimage.sip"
#include <qimage.h>
#line 15890 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qpixmap.sip"
#include <qpixmap.h>
#line 15893 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 225 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qgl.sip"
#include <qgl.h>
#line 15896 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"


class sipQGLContext : public  ::QGLContext
{
public:
    sipQGLContext(const  ::QGLFormat&, ::QPaintDevice*);
    virtual ~sipQGLContext();

    /*
     * There is a public method for every protected method visible from
     * this class.
     */
    void* sipProtectVirt_chooseVisual(bool);
    bool sipProtectVirt_chooseContext(bool,const  ::QGLContext*);
    bool sipProtect_deviceIsPixmap() const;
    bool sipProtect_windowCreated() const;
    void sipProtect_setWindowCreated(bool);
    bool sipProtect_initialized() const;
    void sipProtect_setInitialized(bool);
    void sipProtect_generateFontDisplayLists(const  ::QFont&,int);

    /*
     * There is a protected method for every virtual method visible from
     * this class.
     */
protected:
    bool chooseContext(const  ::QGLContext*);
    void* chooseVisual();
    void swapBuffers() const;
    void doneCurrent();
    void makeCurrent();
    bool create(const  ::QGLContext*);

public:
    sipSimpleWrapper *sipPySelf;

private:
    sipQGLContext(const sipQGLContext &);
    sipQGLContext &operator = (const sipQGLContext &);

    char sipPyMethods[6];
};

sipQGLContext::sipQGLContext(const  ::QGLFormat& a0, ::QPaintDevice*a1):  ::QGLContext(a0,a1), sipPySelf(0)
{
    memset(sipPyMethods, 0, sizeof (sipPyMethods));
}

sipQGLContext::~sipQGLContext()
{
    sipInstanceDestroyedEx(&sipPySelf);
}

bool sipQGLContext::chooseContext(const  ::QGLContext*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[0],sipPySelf,NULL,sipName_chooseContext);

    if (!sipMeth)
        return  ::QGLContext::chooseContext(a0);

    extern bool sipVH_QtOpenGL_0(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const  ::QGLContext*);

    return sipVH_QtOpenGL_0(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void* sipQGLContext::chooseVisual()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[1],sipPySelf,NULL,sipName_chooseVisual);

    if (!sipMeth)
        return  ::QGLContext::chooseVisual();

    extern void* sipVH_QtOpenGL_2(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    return sipVH_QtOpenGL_2(sipGILState, 0, sipPySelf, sipMeth);
}

void sipQGLContext::swapBuffers() const
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,const_cast<char *>(&sipPyMethods[2]),sipPySelf,NULL,sipName_swapBuffers);

    if (!sipMeth)
    {
         ::QGLContext::swapBuffers();
        return;
    }

    extern void sipVH_QtOpenGL_1(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    sipVH_QtOpenGL_1(sipGILState, 0, sipPySelf, sipMeth);
}

void sipQGLContext::doneCurrent()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[3],sipPySelf,NULL,sipName_doneCurrent);

    if (!sipMeth)
    {
         ::QGLContext::doneCurrent();
        return;
    }

    extern void sipVH_QtOpenGL_1(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    sipVH_QtOpenGL_1(sipGILState, 0, sipPySelf, sipMeth);
}

void sipQGLContext::makeCurrent()
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[4],sipPySelf,NULL,sipName_makeCurrent);

    if (!sipMeth)
    {
         ::QGLContext::makeCurrent();
        return;
    }

    extern void sipVH_QtOpenGL_1(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *);

    sipVH_QtOpenGL_1(sipGILState, 0, sipPySelf, sipMeth);
}

bool sipQGLContext::create(const  ::QGLContext*a0)
{
    sip_gilstate_t sipGILState;
    PyObject *sipMeth;

    sipMeth = sipIsPyMethod(&sipGILState,&sipPyMethods[5],sipPySelf,NULL,sipName_create);

    if (!sipMeth)
        return  ::QGLContext::create(a0);

    extern bool sipVH_QtOpenGL_0(sip_gilstate_t, sipVirtErrorHandlerFunc, sipSimpleWrapper *, PyObject *, const  ::QGLContext*);

    return sipVH_QtOpenGL_0(sipGILState, 0, sipPySelf, sipMeth, a0);
}

void* sipQGLContext::sipProtectVirt_chooseVisual(bool sipSelfWasArg)
{
    return (sipSelfWasArg ?  ::QGLContext::chooseVisual() : chooseVisual());
}

bool sipQGLContext::sipProtectVirt_chooseContext(bool sipSelfWasArg,const  ::QGLContext*a0)
{
    return (sipSelfWasArg ?  ::QGLContext::chooseContext(a0) : chooseContext(a0));
}

bool sipQGLContext::sipProtect_deviceIsPixmap() const
{
    return  ::QGLContext::deviceIsPixmap();
}

bool sipQGLContext::sipProtect_windowCreated() const
{
    return  ::QGLContext::windowCreated();
}

void sipQGLContext::sipProtect_setWindowCreated(bool a0)
{
     ::QGLContext::setWindowCreated(a0);
}

bool sipQGLContext::sipProtect_initialized() const
{
    return  ::QGLContext::initialized();
}

void sipQGLContext::sipProtect_setInitialized(bool a0)
{
     ::QGLContext::setInitialized(a0);
}

void sipQGLContext::sipProtect_generateFontDisplayLists(const  ::QFont& a0,int a1)
{
     ::QGLContext::generateFontDisplayLists(a0,a1);
}


PyDoc_STRVAR(doc_QGLContext_create, "create(self, shareContext: QGLContext = None) -> bool");

extern "C" {static PyObject *meth_QGLContext_create(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLContext_create(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        const  ::QGLContext* a0 = 0;
         ::QGLContext *sipCpp;

        static const char *sipKwdList[] = {
            sipName_shareContext,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "B|J8", &sipSelf, sipType_QGLContext, &sipCpp, sipType_QGLContext, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = (sipSelfWasArg ? sipCpp-> ::QGLContext::create(a0) : sipCpp->create(a0));
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLContext, sipName_create, doc_QGLContext_create);

    return NULL;
}


PyDoc_STRVAR(doc_QGLContext_isValid, "isValid(self) -> bool");

extern "C" {static PyObject *meth_QGLContext_isValid(PyObject *, PyObject *);}
static PyObject *meth_QGLContext_isValid(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLContext *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLContext, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isValid();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLContext, sipName_isValid, doc_QGLContext_isValid);

    return NULL;
}


PyDoc_STRVAR(doc_QGLContext_isSharing, "isSharing(self) -> bool");

extern "C" {static PyObject *meth_QGLContext_isSharing(PyObject *, PyObject *);}
static PyObject *meth_QGLContext_isSharing(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLContext *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLContext, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->isSharing();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLContext, sipName_isSharing, doc_QGLContext_isSharing);

    return NULL;
}


PyDoc_STRVAR(doc_QGLContext_reset, "reset(self)");

extern "C" {static PyObject *meth_QGLContext_reset(PyObject *, PyObject *);}
static PyObject *meth_QGLContext_reset(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLContext *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLContext, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->reset();
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLContext, sipName_reset, doc_QGLContext_reset);

    return NULL;
}


PyDoc_STRVAR(doc_QGLContext_format, "format(self) -> QGLFormat");

extern "C" {static PyObject *meth_QGLContext_format(PyObject *, PyObject *);}
static PyObject *meth_QGLContext_format(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLContext *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLContext, &sipCpp))
        {
             ::QGLFormat*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QGLFormat(sipCpp->format());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QGLFormat,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLContext, sipName_format, doc_QGLContext_format);

    return NULL;
}


PyDoc_STRVAR(doc_QGLContext_requestedFormat, "requestedFormat(self) -> QGLFormat");

extern "C" {static PyObject *meth_QGLContext_requestedFormat(PyObject *, PyObject *);}
static PyObject *meth_QGLContext_requestedFormat(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLContext *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLContext, &sipCpp))
        {
             ::QGLFormat*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QGLFormat(sipCpp->requestedFormat());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QGLFormat,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLContext, sipName_requestedFormat, doc_QGLContext_requestedFormat);

    return NULL;
}


PyDoc_STRVAR(doc_QGLContext_setFormat, "setFormat(self, QGLFormat)");

extern "C" {static PyObject *meth_QGLContext_setFormat(PyObject *, PyObject *);}
static PyObject *meth_QGLContext_setFormat(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFormat* a0;
         ::QGLContext *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ9", &sipSelf, sipType_QGLContext, &sipCpp, sipType_QGLFormat, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setFormat(*a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLContext, sipName_setFormat, doc_QGLContext_setFormat);

    return NULL;
}


PyDoc_STRVAR(doc_QGLContext_makeCurrent, "makeCurrent(self)");

extern "C" {static PyObject *meth_QGLContext_makeCurrent(PyObject *, PyObject *);}
static PyObject *meth_QGLContext_makeCurrent(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QGLContext *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLContext, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp-> ::QGLContext::makeCurrent() : sipCpp->makeCurrent());
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLContext, sipName_makeCurrent, doc_QGLContext_makeCurrent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLContext_doneCurrent, "doneCurrent(self)");

extern "C" {static PyObject *meth_QGLContext_doneCurrent(PyObject *, PyObject *);}
static PyObject *meth_QGLContext_doneCurrent(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
         ::QGLContext *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLContext, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp-> ::QGLContext::doneCurrent() : sipCpp->doneCurrent());
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLContext, sipName_doneCurrent, doc_QGLContext_doneCurrent);

    return NULL;
}


PyDoc_STRVAR(doc_QGLContext_swapBuffers, "swapBuffers(self)");

extern "C" {static PyObject *meth_QGLContext_swapBuffers(PyObject *, PyObject *);}
static PyObject *meth_QGLContext_swapBuffers(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        const  ::QGLContext *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLContext, &sipCpp))
        {
            Py_BEGIN_ALLOW_THREADS
            (sipSelfWasArg ? sipCpp-> ::QGLContext::swapBuffers() : sipCpp->swapBuffers());
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLContext, sipName_swapBuffers, doc_QGLContext_swapBuffers);

    return NULL;
}


PyDoc_STRVAR(doc_QGLContext_bindTexture, "bindTexture(self, QImage, target: int = GL_TEXTURE_2D, format: int = GL_RGBA) -> int\n"
"bindTexture(self, QPixmap, target: int = GL_TEXTURE_2D, format: int = GL_RGBA) -> int\n"
"bindTexture(self, str) -> int\n"
"bindTexture(self, QImage, int, int, QGLContext.BindOptions) -> int\n"
"bindTexture(self, QPixmap, int, int, QGLContext.BindOptions) -> int");

extern "C" {static PyObject *meth_QGLContext_bindTexture(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLContext_bindTexture(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QImage* a0;
         ::GLenum a1 = GL_TEXTURE_2D;
         ::GLint a2 = GL_RGBA;
         ::QGLContext *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            sipName_target,
            sipName_format,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ9|ui", &sipSelf, sipType_QGLContext, &sipCpp, sipType_QImage, &a0, &a1, &a2))
        {
             ::GLuint sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->bindTexture(*a0,a1,a2);
            Py_END_ALLOW_THREADS

            return PyLong_FromUnsignedLong(sipRes);
        }
    }

    {
        const  ::QPixmap* a0;
         ::GLenum a1 = GL_TEXTURE_2D;
         ::GLint a2 = GL_RGBA;
         ::QGLContext *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            sipName_target,
            sipName_format,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ9|ui", &sipSelf, sipType_QGLContext, &sipCpp, sipType_QPixmap, &a0, &a1, &a2))
        {
             ::GLuint sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->bindTexture(*a0,a1,a2);
            Py_END_ALLOW_THREADS

            return PyLong_FromUnsignedLong(sipRes);
        }
    }

    {
        const  ::QString* a0;
        int a0State = 0;
         ::QGLContext *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ1", &sipSelf, sipType_QGLContext, &sipCpp, sipType_QString,&a0, &a0State))
        {
             ::GLuint sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->bindTexture(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);

            return PyLong_FromUnsignedLong(sipRes);
        }
    }

    {
        const  ::QImage* a0;
         ::GLenum a1;
         ::GLint a2;
         ::QGLContext::BindOptions* a3;
        int a3State = 0;
         ::QGLContext *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9uiJ1", &sipSelf, sipType_QGLContext, &sipCpp, sipType_QImage, &a0, &a1, &a2, sipType_QGLContext_BindOptions, &a3, &a3State))
        {
             ::GLuint sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->bindTexture(*a0,a1,a2,*a3);
            Py_END_ALLOW_THREADS
            sipReleaseType(a3,sipType_QGLContext_BindOptions,a3State);

            return PyLong_FromUnsignedLong(sipRes);
        }
    }

    {
        const  ::QPixmap* a0;
         ::GLenum a1;
         ::GLint a2;
         ::QGLContext::BindOptions* a3;
        int a3State = 0;
         ::QGLContext *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9uiJ1", &sipSelf, sipType_QGLContext, &sipCpp, sipType_QPixmap, &a0, &a1, &a2, sipType_QGLContext_BindOptions, &a3, &a3State))
        {
             ::GLuint sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->bindTexture(*a0,a1,a2,*a3);
            Py_END_ALLOW_THREADS
            sipReleaseType(a3,sipType_QGLContext_BindOptions,a3State);

            return PyLong_FromUnsignedLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLContext, sipName_bindTexture, doc_QGLContext_bindTexture);

    return NULL;
}


PyDoc_STRVAR(doc_QGLContext_drawTexture, "drawTexture(self, QRectF, int, textureTarget: int = GL_TEXTURE_2D)\n"
"drawTexture(self, Union[QPointF, QPoint], int, textureTarget: int = GL_TEXTURE_2D)");

extern "C" {static PyObject *meth_QGLContext_drawTexture(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLContext_drawTexture(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QRectF* a0;
         ::GLuint a1;
         ::GLenum a2 = GL_TEXTURE_2D;
         ::QGLContext *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_textureTarget,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ9u|u", &sipSelf, sipType_QGLContext, &sipCpp, sipType_QRectF, &a0, &a1, &a2))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->drawTexture(*a0,a1,a2);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    {
        const  ::QPointF* a0;
        int a0State = 0;
         ::GLuint a1;
         ::GLenum a2 = GL_TEXTURE_2D;
         ::QGLContext *sipCpp;

        static const char *sipKwdList[] = {
            NULL,
            NULL,
            sipName_textureTarget,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "BJ1u|u", &sipSelf, sipType_QGLContext, &sipCpp, sipType_QPointF, &a0, &a0State, &a1, &a2))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->drawTexture(*a0,a1,a2);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::QPointF *>(a0),sipType_QPointF,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLContext, sipName_drawTexture, doc_QGLContext_drawTexture);

    return NULL;
}


PyDoc_STRVAR(doc_QGLContext_chooseVisual, "chooseVisual(self) -> sip.voidptr");

extern "C" {static PyObject *meth_QGLContext_chooseVisual(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLContext_chooseVisual(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        sipQGLContext *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QGLContext, &sipCpp))
        {
            void*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtectVirt_chooseVisual(sipSelfWasArg);
            Py_END_ALLOW_THREADS

            return sipConvertFromVoidPtr(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLContext, sipName_chooseVisual, doc_QGLContext_chooseVisual);

    return NULL;
}


PyDoc_STRVAR(doc_QGLContext_deleteTexture, "deleteTexture(self, int)");

extern "C" {static PyObject *meth_QGLContext_deleteTexture(PyObject *, PyObject *);}
static PyObject *meth_QGLContext_deleteTexture(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::GLuint a0;
         ::QGLContext *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bu", &sipSelf, sipType_QGLContext, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->deleteTexture(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLContext, sipName_deleteTexture, doc_QGLContext_deleteTexture);

    return NULL;
}


PyDoc_STRVAR(doc_QGLContext_setTextureCacheLimit, "setTextureCacheLimit(int)");

extern "C" {static PyObject *meth_QGLContext_setTextureCacheLimit(PyObject *, PyObject *);}
static PyObject *meth_QGLContext_setTextureCacheLimit(PyObject *, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;

        if (sipParseArgs(&sipParseErr, sipArgs, "i", &a0))
        {
            Py_BEGIN_ALLOW_THREADS
             ::QGLContext::setTextureCacheLimit(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLContext, sipName_setTextureCacheLimit, doc_QGLContext_setTextureCacheLimit);

    return NULL;
}


PyDoc_STRVAR(doc_QGLContext_textureCacheLimit, "textureCacheLimit() -> int");

extern "C" {static PyObject *meth_QGLContext_textureCacheLimit(PyObject *, PyObject *);}
static PyObject *meth_QGLContext_textureCacheLimit(PyObject *, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        if (sipParseArgs(&sipParseErr, sipArgs, ""))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes =  ::QGLContext::textureCacheLimit();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLContext, sipName_textureCacheLimit, doc_QGLContext_textureCacheLimit);

    return NULL;
}


PyDoc_STRVAR(doc_QGLContext_getProcAddress, "getProcAddress(self, str) -> sip.voidptr");

extern "C" {static PyObject *meth_QGLContext_getProcAddress(PyObject *, PyObject *);}
static PyObject *meth_QGLContext_getProcAddress(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QString* a0;
        int a0State = 0;
        const  ::QGLContext *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QGLContext, &sipCpp, sipType_QString,&a0, &a0State))
        {
            void*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->getProcAddress(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::QString *>(a0),sipType_QString,a0State);

            return sipConvertFromVoidPtr(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLContext, sipName_getProcAddress, doc_QGLContext_getProcAddress);

    return NULL;
}


PyDoc_STRVAR(doc_QGLContext_device, "device(self) -> QPaintDevice");

extern "C" {static PyObject *meth_QGLContext_device(PyObject *, PyObject *);}
static PyObject *meth_QGLContext_device(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLContext *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLContext, &sipCpp))
        {
             ::QPaintDevice*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->device();
            Py_END_ALLOW_THREADS

            return sipConvertFromType(sipRes,sipType_QPaintDevice,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLContext, sipName_device, doc_QGLContext_device);

    return NULL;
}


PyDoc_STRVAR(doc_QGLContext_overlayTransparentColor, "overlayTransparentColor(self) -> QColor");

extern "C" {static PyObject *meth_QGLContext_overlayTransparentColor(PyObject *, PyObject *);}
static PyObject *meth_QGLContext_overlayTransparentColor(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLContext *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLContext, &sipCpp))
        {
             ::QColor*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QColor(sipCpp->overlayTransparentColor());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QColor,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLContext, sipName_overlayTransparentColor, doc_QGLContext_overlayTransparentColor);

    return NULL;
}


PyDoc_STRVAR(doc_QGLContext_currentContext, "currentContext() -> QGLContext");

extern "C" {static PyObject *meth_QGLContext_currentContext(PyObject *, PyObject *);}
static PyObject *meth_QGLContext_currentContext(PyObject *, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        if (sipParseArgs(&sipParseErr, sipArgs, ""))
        {
            const  ::QGLContext*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes =  ::QGLContext::currentContext();
            Py_END_ALLOW_THREADS

            return sipConvertFromType(const_cast< ::QGLContext *>(sipRes),sipType_QGLContext,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLContext, sipName_currentContext, doc_QGLContext_currentContext);

    return NULL;
}


PyDoc_STRVAR(doc_QGLContext_chooseContext, "chooseContext(self, shareContext: QGLContext = None) -> bool");

extern "C" {static PyObject *meth_QGLContext_chooseContext(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLContext_chooseContext(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;
    bool sipSelfWasArg = (!sipSelf || sipIsDerivedClass((sipSimpleWrapper *)sipSelf));

    {
        const  ::QGLContext* a0 = 0;
        sipQGLContext *sipCpp;

        static const char *sipKwdList[] = {
            sipName_shareContext,
        };

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, sipKwdList, NULL, "B|J8", &sipSelf, sipType_QGLContext, &sipCpp, sipType_QGLContext, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtectVirt_chooseContext(sipSelfWasArg,a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLContext, sipName_chooseContext, doc_QGLContext_chooseContext);

    return NULL;
}


PyDoc_STRVAR(doc_QGLContext_deviceIsPixmap, "deviceIsPixmap(self) -> bool");

extern "C" {static PyObject *meth_QGLContext_deviceIsPixmap(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLContext_deviceIsPixmap(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQGLContext *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QGLContext, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_deviceIsPixmap();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLContext, sipName_deviceIsPixmap, doc_QGLContext_deviceIsPixmap);

    return NULL;
}


PyDoc_STRVAR(doc_QGLContext_windowCreated, "windowCreated(self) -> bool");

extern "C" {static PyObject *meth_QGLContext_windowCreated(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLContext_windowCreated(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQGLContext *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QGLContext, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_windowCreated();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLContext, sipName_windowCreated, doc_QGLContext_windowCreated);

    return NULL;
}


PyDoc_STRVAR(doc_QGLContext_setWindowCreated, "setWindowCreated(self, bool)");

extern "C" {static PyObject *meth_QGLContext_setWindowCreated(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLContext_setWindowCreated(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        bool a0;
        sipQGLContext *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "Bb", &sipSelf, sipType_QGLContext, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_setWindowCreated(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLContext, sipName_setWindowCreated, doc_QGLContext_setWindowCreated);

    return NULL;
}


PyDoc_STRVAR(doc_QGLContext_initialized, "initialized(self) -> bool");

extern "C" {static PyObject *meth_QGLContext_initialized(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLContext_initialized(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const sipQGLContext *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "B", &sipSelf, sipType_QGLContext, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sipProtect_initialized();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLContext, sipName_initialized, doc_QGLContext_initialized);

    return NULL;
}


PyDoc_STRVAR(doc_QGLContext_setInitialized, "setInitialized(self, bool)");

extern "C" {static PyObject *meth_QGLContext_setInitialized(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLContext_setInitialized(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        bool a0;
        sipQGLContext *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "Bb", &sipSelf, sipType_QGLContext, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_setInitialized(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLContext, sipName_setInitialized, doc_QGLContext_setInitialized);

    return NULL;
}


PyDoc_STRVAR(doc_QGLContext_generateFontDisplayLists, "generateFontDisplayLists(self, QFont, int)");

extern "C" {static PyObject *meth_QGLContext_generateFontDisplayLists(PyObject *, PyObject *, PyObject *);}
static PyObject *meth_QGLContext_generateFontDisplayLists(PyObject *sipSelf, PyObject *sipArgs, PyObject *sipKwds)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QFont* a0;
        int a1;
        sipQGLContext *sipCpp;

        if (sipParseKwdArgs(&sipParseErr, sipArgs, sipKwds, NULL, NULL, "BJ9i", &sipSelf, sipType_QGLContext, &sipCpp, sipType_QFont, &a0, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->sipProtect_generateFontDisplayLists(*a0,a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLContext, sipName_generateFontDisplayLists, doc_QGLContext_generateFontDisplayLists);

    return NULL;
}


PyDoc_STRVAR(doc_QGLContext_areSharing, "areSharing(QGLContext, QGLContext) -> bool");

extern "C" {static PyObject *meth_QGLContext_areSharing(PyObject *, PyObject *);}
static PyObject *meth_QGLContext_areSharing(PyObject *, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLContext* a0;
        const  ::QGLContext* a1;

        if (sipParseArgs(&sipParseErr, sipArgs, "J8J8", sipType_QGLContext, &a0, sipType_QGLContext, &a1))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes =  ::QGLContext::areSharing(a0,a1);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLContext, sipName_areSharing, doc_QGLContext_areSharing);

    return NULL;
}


/* Call the instance's destructor. */
extern "C" {static void release_QGLContext(void *, int);}
static void release_QGLContext(void *sipCppV, int sipState)
{
    Py_BEGIN_ALLOW_THREADS

    if (sipState & SIP_DERIVED_CLASS)
        delete reinterpret_cast<sipQGLContext *>(sipCppV);
    else
        delete reinterpret_cast< ::QGLContext *>(sipCppV);

    Py_END_ALLOW_THREADS
}


extern "C" {static void dealloc_QGLContext(sipSimpleWrapper *);}
static void dealloc_QGLContext(sipSimpleWrapper *sipSelf)
{
    if (sipIsDerivedClass(sipSelf))
        reinterpret_cast<sipQGLContext *>(sipGetAddress(sipSelf))->sipPySelf = NULL;

    if (sipIsOwnedByPython(sipSelf))
    {
        release_QGLContext(sipGetAddress(sipSelf), sipIsDerivedClass(sipSelf));
    }
}


extern "C" {static void *init_type_QGLContext(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QGLContext(sipSimpleWrapper *sipSelf, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
    sipQGLContext *sipCpp = 0;

    {
        const  ::QGLFormat* a0;
         ::QPaintDevice* a1;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9J8", sipType_QGLFormat, &a0, sipType_QPaintDevice, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new sipQGLContext(*a0,a1);
            Py_END_ALLOW_THREADS

            sipCpp->sipPySelf = sipSelf;

            return sipCpp;
        }
    }

    return NULL;
}


static PyMethodDef methods_QGLContext[] = {
    {SIP_MLNAME_CAST(sipName_areSharing), meth_QGLContext_areSharing, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLContext_areSharing)},
    {SIP_MLNAME_CAST(sipName_bindTexture), (PyCFunction)meth_QGLContext_bindTexture, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLContext_bindTexture)},
    {SIP_MLNAME_CAST(sipName_chooseContext), (PyCFunction)meth_QGLContext_chooseContext, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLContext_chooseContext)},
    {SIP_MLNAME_CAST(sipName_chooseVisual), (PyCFunction)meth_QGLContext_chooseVisual, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLContext_chooseVisual)},
    {SIP_MLNAME_CAST(sipName_create), (PyCFunction)meth_QGLContext_create, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLContext_create)},
    {SIP_MLNAME_CAST(sipName_currentContext), meth_QGLContext_currentContext, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLContext_currentContext)},
    {SIP_MLNAME_CAST(sipName_deleteTexture), meth_QGLContext_deleteTexture, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLContext_deleteTexture)},
    {SIP_MLNAME_CAST(sipName_device), meth_QGLContext_device, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLContext_device)},
    {SIP_MLNAME_CAST(sipName_deviceIsPixmap), (PyCFunction)meth_QGLContext_deviceIsPixmap, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLContext_deviceIsPixmap)},
    {SIP_MLNAME_CAST(sipName_doneCurrent), meth_QGLContext_doneCurrent, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLContext_doneCurrent)},
    {SIP_MLNAME_CAST(sipName_drawTexture), (PyCFunction)meth_QGLContext_drawTexture, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLContext_drawTexture)},
    {SIP_MLNAME_CAST(sipName_format), meth_QGLContext_format, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLContext_format)},
    {SIP_MLNAME_CAST(sipName_generateFontDisplayLists), (PyCFunction)meth_QGLContext_generateFontDisplayLists, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLContext_generateFontDisplayLists)},
    {SIP_MLNAME_CAST(sipName_getProcAddress), meth_QGLContext_getProcAddress, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLContext_getProcAddress)},
    {SIP_MLNAME_CAST(sipName_initialized), (PyCFunction)meth_QGLContext_initialized, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLContext_initialized)},
    {SIP_MLNAME_CAST(sipName_isSharing), meth_QGLContext_isSharing, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLContext_isSharing)},
    {SIP_MLNAME_CAST(sipName_isValid), meth_QGLContext_isValid, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLContext_isValid)},
    {SIP_MLNAME_CAST(sipName_makeCurrent), meth_QGLContext_makeCurrent, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLContext_makeCurrent)},
    {SIP_MLNAME_CAST(sipName_overlayTransparentColor), meth_QGLContext_overlayTransparentColor, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLContext_overlayTransparentColor)},
    {SIP_MLNAME_CAST(sipName_requestedFormat), meth_QGLContext_requestedFormat, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLContext_requestedFormat)},
    {SIP_MLNAME_CAST(sipName_reset), meth_QGLContext_reset, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLContext_reset)},
    {SIP_MLNAME_CAST(sipName_setFormat), meth_QGLContext_setFormat, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLContext_setFormat)},
    {SIP_MLNAME_CAST(sipName_setInitialized), (PyCFunction)meth_QGLContext_setInitialized, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLContext_setInitialized)},
    {SIP_MLNAME_CAST(sipName_setTextureCacheLimit), meth_QGLContext_setTextureCacheLimit, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLContext_setTextureCacheLimit)},
    {SIP_MLNAME_CAST(sipName_setWindowCreated), (PyCFunction)meth_QGLContext_setWindowCreated, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLContext_setWindowCreated)},
    {SIP_MLNAME_CAST(sipName_swapBuffers), meth_QGLContext_swapBuffers, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLContext_swapBuffers)},
    {SIP_MLNAME_CAST(sipName_textureCacheLimit), meth_QGLContext_textureCacheLimit, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLContext_textureCacheLimit)},
    {SIP_MLNAME_CAST(sipName_windowCreated), (PyCFunction)meth_QGLContext_windowCreated, METH_VARARGS|METH_KEYWORDS, SIP_MLDOC_CAST(doc_QGLContext_windowCreated)}
};

static sipEnumMemberDef enummembers_QGLContext[] = {
    {sipName_DefaultBindOption, static_cast<int>( ::QGLContext::DefaultBindOption), 9},
    {sipName_InvertedYBindOption, static_cast<int>( ::QGLContext::InvertedYBindOption), 9},
    {sipName_LinearFilteringBindOption, static_cast<int>( ::QGLContext::LinearFilteringBindOption), 9},
    {sipName_MipmapBindOption, static_cast<int>( ::QGLContext::MipmapBindOption), 9},
    {sipName_NoBindOption, static_cast<int>( ::QGLContext::NoBindOption), 9},
    {sipName_PremultipliedAlphaBindOption, static_cast<int>( ::QGLContext::PremultipliedAlphaBindOption), 9},
};

PyDoc_STRVAR(doc_QGLContext, "\1QGLContext(QGLFormat, QPaintDevice)");


static pyqt4ClassPluginDef plugin_QGLContext = {
    0,
    0,
    0
};


sipClassTypeDef sipTypeDef_QtOpenGL_QGLContext = {
    {
        -1,
        0,
        0,
        SIP_TYPE_CLASS,
        sipNameNr_QGLContext,
        {0},
        &plugin_QGLContext
    },
    {
        sipNameNr_QGLContext,
        {0, 0, 1},
        28, methods_QGLContext,
        6, enummembers_QGLContext,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QGLContext,
    sipNameNr_PyQt4_QtCore_pyqtWrapperType,
    -1,
    0,
    0,
    init_type_QGLContext,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QGLContext,
    0,
    0,
    0,
    release_QGLContext,
    0,
    0,
    0,
    0,
    0,
    0,
    0
};

#line 70 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qgl.sip"
#include <qgl.h>
#line 17233 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

#line 70 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qgl.sip"
#include <qgl.h>
#line 17237 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"


extern "C" {static int slot_QGLFormat_OpenGLVersionFlags___bool__(PyObject *);}
static int slot_QGLFormat_OpenGLVersionFlags___bool__(PyObject *sipSelf)
{
     ::QGLFormat::OpenGLVersionFlags *sipCpp = reinterpret_cast< ::QGLFormat::OpenGLVersionFlags *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGLFormat_OpenGLVersionFlags));

    if (!sipCpp)
        return -1;


    {
        {
            int sipRes = 0;

#line 381 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qglobal.sip"
#if QT_VERSION >= 0x050000
        sipRes = (sipCpp->operator QGLFormat::OpenGLVersionFlags::Int() != 0);
#else
        sipRes = (sipCpp->operator int() != 0);
#endif
#line 17259 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

            return sipRes;
        }
    }

    return 0;
}


extern "C" {static PyObject *slot_QGLFormat_OpenGLVersionFlags___ne__(PyObject *,PyObject *);}
static PyObject *slot_QGLFormat_OpenGLVersionFlags___ne__(PyObject *sipSelf,PyObject *sipArg)
{
     ::QGLFormat::OpenGLVersionFlags *sipCpp = reinterpret_cast< ::QGLFormat::OpenGLVersionFlags *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGLFormat_OpenGLVersionFlags));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFormat::OpenGLVersionFlags* a0;
        int a0State = 0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J1", sipType_QGLFormat_OpenGLVersionFlags, &a0, &a0State))
        {
            bool sipRes = 0;

#line 372 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qglobal.sip"
#if QT_VERSION >= 0x050000
        sipRes = (sipCpp->operator QGLFormat::OpenGLVersionFlags::Int() != a0->operator QGLFormat::OpenGLVersionFlags::Int());
#else
        sipRes = (sipCpp->operator int() != a0->operator int());
#endif
#line 17293 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
            sipReleaseType(const_cast< ::QGLFormat::OpenGLVersionFlags *>(a0),sipType_QGLFormat_OpenGLVersionFlags,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtOpenGL, ne_slot, sipType_QGLFormat_OpenGLVersionFlags, sipSelf, sipArg);
}


extern "C" {static PyObject *slot_QGLFormat_OpenGLVersionFlags___eq__(PyObject *,PyObject *);}
static PyObject *slot_QGLFormat_OpenGLVersionFlags___eq__(PyObject *sipSelf,PyObject *sipArg)
{
     ::QGLFormat::OpenGLVersionFlags *sipCpp = reinterpret_cast< ::QGLFormat::OpenGLVersionFlags *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGLFormat_OpenGLVersionFlags));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFormat::OpenGLVersionFlags* a0;
        int a0State = 0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J1", sipType_QGLFormat_OpenGLVersionFlags, &a0, &a0State))
        {
            bool sipRes = 0;

#line 363 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qglobal.sip"
#if QT_VERSION >= 0x050000
        sipRes = (sipCpp->operator QGLFormat::OpenGLVersionFlags::Int() == a0->operator QGLFormat::OpenGLVersionFlags::Int());
#else
        sipRes = (sipCpp->operator int() == a0->operator int());
#endif
#line 17333 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
            sipReleaseType(const_cast< ::QGLFormat::OpenGLVersionFlags *>(a0),sipType_QGLFormat_OpenGLVersionFlags,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtOpenGL, eq_slot, sipType_QGLFormat_OpenGLVersionFlags, sipSelf, sipArg);
}


extern "C" {static PyObject *slot_QGLFormat_OpenGLVersionFlags___ixor__(PyObject *,PyObject *);}
static PyObject *slot_QGLFormat_OpenGLVersionFlags___ixor__(PyObject *sipSelf,PyObject *sipArg)
{
    if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QGLFormat_OpenGLVersionFlags)))
    {
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    }

     ::QGLFormat::OpenGLVersionFlags *sipCpp = reinterpret_cast< ::QGLFormat::OpenGLVersionFlags *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGLFormat_OpenGLVersionFlags));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        int a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1i", &a0))
        {
#line 357 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qglobal.sip"
        *sipCpp = QGLFormat::OpenGLVersionFlags(*sipCpp ^ a0);
#line 17372 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

            Py_INCREF(sipSelf);
            return sipSelf;
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    PyErr_Clear();

    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}


extern "C" {static PyObject *slot_QGLFormat_OpenGLVersionFlags___xor__(PyObject *,PyObject *);}
static PyObject *slot_QGLFormat_OpenGLVersionFlags___xor__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLFormat::OpenGLVersionFlags* a0;
        int a0State = 0;
        int a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J1i", sipType_QGLFormat_OpenGLVersionFlags, &a0, &a0State, &a1))
        {
             ::QGLFormat::OpenGLVersionFlags*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QGLFormat::OpenGLVersionFlags((*a0 ^ a1));
            Py_END_ALLOW_THREADS
            sipReleaseType(a0,sipType_QGLFormat_OpenGLVersionFlags,a0State);

            return sipConvertFromNewType(sipRes,sipType_QGLFormat_OpenGLVersionFlags,NULL);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtOpenGL, xor_slot, NULL, sipArg0, sipArg1);
}


extern "C" {static PyObject *slot_QGLFormat_OpenGLVersionFlags___ior__(PyObject *,PyObject *);}
static PyObject *slot_QGLFormat_OpenGLVersionFlags___ior__(PyObject *sipSelf,PyObject *sipArg)
{
    if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QGLFormat_OpenGLVersionFlags)))
    {
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    }

     ::QGLFormat::OpenGLVersionFlags *sipCpp = reinterpret_cast< ::QGLFormat::OpenGLVersionFlags *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGLFormat_OpenGLVersionFlags));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        int a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1i", &a0))
        {
#line 351 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qglobal.sip"
        *sipCpp = QGLFormat::OpenGLVersionFlags(*sipCpp | a0);
#line 17446 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

            Py_INCREF(sipSelf);
            return sipSelf;
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    PyErr_Clear();

    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}


extern "C" {static PyObject *slot_QGLFormat_OpenGLVersionFlags___or__(PyObject *,PyObject *);}
static PyObject *slot_QGLFormat_OpenGLVersionFlags___or__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLFormat::OpenGLVersionFlags* a0;
        int a0State = 0;
        int a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J1i", sipType_QGLFormat_OpenGLVersionFlags, &a0, &a0State, &a1))
        {
             ::QGLFormat::OpenGLVersionFlags*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QGLFormat::OpenGLVersionFlags((*a0 | a1));
            Py_END_ALLOW_THREADS
            sipReleaseType(a0,sipType_QGLFormat_OpenGLVersionFlags,a0State);

            return sipConvertFromNewType(sipRes,sipType_QGLFormat_OpenGLVersionFlags,NULL);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtOpenGL, or_slot, NULL, sipArg0, sipArg1);
}


extern "C" {static PyObject *slot_QGLFormat_OpenGLVersionFlags___iand__(PyObject *,PyObject *);}
static PyObject *slot_QGLFormat_OpenGLVersionFlags___iand__(PyObject *sipSelf,PyObject *sipArg)
{
    if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QGLFormat_OpenGLVersionFlags)))
    {
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    }

     ::QGLFormat::OpenGLVersionFlags *sipCpp = reinterpret_cast< ::QGLFormat::OpenGLVersionFlags *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGLFormat_OpenGLVersionFlags));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        int a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1i", &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp-> ::QGLFormat::OpenGLVersionFlags::operator&=(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(sipSelf);
            return sipSelf;
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    PyErr_Clear();

    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}


extern "C" {static PyObject *slot_QGLFormat_OpenGLVersionFlags___and__(PyObject *,PyObject *);}
static PyObject *slot_QGLFormat_OpenGLVersionFlags___and__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLFormat::OpenGLVersionFlags* a0;
        int a0State = 0;
        int a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J1i", sipType_QGLFormat_OpenGLVersionFlags, &a0, &a0State, &a1))
        {
             ::QGLFormat::OpenGLVersionFlags*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QGLFormat::OpenGLVersionFlags((*a0 & a1));
            Py_END_ALLOW_THREADS
            sipReleaseType(a0,sipType_QGLFormat_OpenGLVersionFlags,a0State);

            return sipConvertFromNewType(sipRes,sipType_QGLFormat_OpenGLVersionFlags,NULL);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtOpenGL, and_slot, NULL, sipArg0, sipArg1);
}


extern "C" {static PyObject *slot_QGLFormat_OpenGLVersionFlags___invert__(PyObject *);}
static PyObject *slot_QGLFormat_OpenGLVersionFlags___invert__(PyObject *sipSelf)
{
     ::QGLFormat::OpenGLVersionFlags *sipCpp = reinterpret_cast< ::QGLFormat::OpenGLVersionFlags *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGLFormat_OpenGLVersionFlags));

    if (!sipCpp)
        return 0;


    {
        {
             ::QGLFormat::OpenGLVersionFlags*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QGLFormat::OpenGLVersionFlags(~(*sipCpp));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QGLFormat_OpenGLVersionFlags,NULL);
        }
    }

    return 0;
}


extern "C" {static PyObject *slot_QGLFormat_OpenGLVersionFlags___int__(PyObject *);}
static PyObject *slot_QGLFormat_OpenGLVersionFlags___int__(PyObject *sipSelf)
{
     ::QGLFormat::OpenGLVersionFlags *sipCpp = reinterpret_cast< ::QGLFormat::OpenGLVersionFlags *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGLFormat_OpenGLVersionFlags));

    if (!sipCpp)
        return 0;


    {
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = *sipCpp;
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    return 0;
}


/* Call the instance's destructor. */
extern "C" {static void release_QGLFormat_OpenGLVersionFlags(void *, int);}
static void release_QGLFormat_OpenGLVersionFlags(void *sipCppV, int)
{
    Py_BEGIN_ALLOW_THREADS

    delete reinterpret_cast< ::QGLFormat::OpenGLVersionFlags *>(sipCppV);

    Py_END_ALLOW_THREADS
}


extern "C" {static void assign_QGLFormat_OpenGLVersionFlags(void *, SIP_SSIZE_T, void *);}
static void assign_QGLFormat_OpenGLVersionFlags(void *sipDst, SIP_SSIZE_T sipDstIdx, void *sipSrc)
{
    reinterpret_cast< ::QGLFormat::OpenGLVersionFlags *>(sipDst)[sipDstIdx] = *reinterpret_cast< ::QGLFormat::OpenGLVersionFlags *>(sipSrc);
}


extern "C" {static void *array_QGLFormat_OpenGLVersionFlags(SIP_SSIZE_T);}
static void *array_QGLFormat_OpenGLVersionFlags(SIP_SSIZE_T sipNrElem)
{
    return new  ::QGLFormat::OpenGLVersionFlags[sipNrElem];
}


extern "C" {static void *copy_QGLFormat_OpenGLVersionFlags(const void *, SIP_SSIZE_T);}
static void *copy_QGLFormat_OpenGLVersionFlags(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new  ::QGLFormat::OpenGLVersionFlags(reinterpret_cast<const  ::QGLFormat::OpenGLVersionFlags *>(sipSrc)[sipSrcIdx]);
}


extern "C" {static void dealloc_QGLFormat_OpenGLVersionFlags(sipSimpleWrapper *);}
static void dealloc_QGLFormat_OpenGLVersionFlags(sipSimpleWrapper *sipSelf)
{
    if (sipIsOwnedByPython(sipSelf))
    {
        release_QGLFormat_OpenGLVersionFlags(sipGetAddress(sipSelf), 0);
    }
}


extern "C" {static void *init_type_QGLFormat_OpenGLVersionFlags(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QGLFormat_OpenGLVersionFlags(sipSimpleWrapper *, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
     ::QGLFormat::OpenGLVersionFlags *sipCpp = 0;

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new  ::QGLFormat::OpenGLVersionFlags();
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    {
        int a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "i", &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new  ::QGLFormat::OpenGLVersionFlags(a0);
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    {
        const  ::QGLFormat::OpenGLVersionFlags* a0;
        int a0State = 0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J1", sipType_QGLFormat_OpenGLVersionFlags, &a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new  ::QGLFormat::OpenGLVersionFlags(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::QGLFormat::OpenGLVersionFlags *>(a0),sipType_QGLFormat_OpenGLVersionFlags,a0State);

            return sipCpp;
        }
    }

    return NULL;
}


extern "C" {static int convertTo_QGLFormat_OpenGLVersionFlags(PyObject *, void **, int *, PyObject *);}
static int convertTo_QGLFormat_OpenGLVersionFlags(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
     ::QGLFormat::OpenGLVersionFlags **sipCppPtr = reinterpret_cast< ::QGLFormat::OpenGLVersionFlags **>(sipCppPtrV);

#line 390 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qglobal.sip"
// Allow an instance of the base enum whenever a QGLFormat::OpenGLVersionFlags is expected.

if (sipIsErr == NULL)
    return (PyObject_TypeCheck(sipPy, sipTypeAsPyTypeObject(sipType_QGLFormat_OpenGLVersionFlag)) ||
            sipCanConvertToType(sipPy, sipType_QGLFormat_OpenGLVersionFlags, SIP_NO_CONVERTORS));

if (PyObject_TypeCheck(sipPy, sipTypeAsPyTypeObject(sipType_QGLFormat_OpenGLVersionFlag)))
{
    *sipCppPtr = new QGLFormat::OpenGLVersionFlags(int(SIPLong_AsLong(sipPy)));

    return sipGetState(sipTransferObj);
}

*sipCppPtr = reinterpret_cast<QGLFormat::OpenGLVersionFlags *>(sipConvertToType(sipPy, sipType_QGLFormat_OpenGLVersionFlags, sipTransferObj, SIP_NO_CONVERTORS, 0, sipIsErr));

return 0;
#line 17734 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
}


/* Define this type's Python slots. */
static sipPySlotDef slots_QGLFormat_OpenGLVersionFlags[] = {
    {(void *)slot_QGLFormat_OpenGLVersionFlags___bool__, bool_slot},
    {(void *)slot_QGLFormat_OpenGLVersionFlags___ne__, ne_slot},
    {(void *)slot_QGLFormat_OpenGLVersionFlags___eq__, eq_slot},
    {(void *)slot_QGLFormat_OpenGLVersionFlags___ixor__, ixor_slot},
    {(void *)slot_QGLFormat_OpenGLVersionFlags___xor__, xor_slot},
    {(void *)slot_QGLFormat_OpenGLVersionFlags___ior__, ior_slot},
    {(void *)slot_QGLFormat_OpenGLVersionFlags___or__, or_slot},
    {(void *)slot_QGLFormat_OpenGLVersionFlags___iand__, iand_slot},
    {(void *)slot_QGLFormat_OpenGLVersionFlags___and__, and_slot},
    {(void *)slot_QGLFormat_OpenGLVersionFlags___invert__, invert_slot},
    {(void *)slot_QGLFormat_OpenGLVersionFlags___int__, int_slot},
    {0, (sipPySlotType)0}
};

PyDoc_STRVAR(doc_QGLFormat_OpenGLVersionFlags, "\1QGLFormat.OpenGLVersionFlags()\n"
"QGLFormat.OpenGLVersionFlags(Union[QGLFormat.OpenGLVersionFlags, QGLFormat.OpenGLVersionFlag])\n"
"QGLFormat.OpenGLVersionFlags(QGLFormat.OpenGLVersionFlags)");


static pyqt4ClassPluginDef plugin_QGLFormat_OpenGLVersionFlags = {
    0,
    1,
    0
};


sipClassTypeDef sipTypeDef_QtOpenGL_QGLFormat_OpenGLVersionFlags = {
    {
        -1,
        0,
        0,
        SIP_TYPE_CLASS,
        sipNameNr_QGLFormat__OpenGLVersionFlags,
        {0},
        &plugin_QGLFormat_OpenGLVersionFlags
    },
    {
        sipNameNr_OpenGLVersionFlags,
        {11, 255, 0},
        0, 0,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QGLFormat_OpenGLVersionFlags,
    sipNameNr_PyQt4_QtCore_pyqtWrapperType,
    sipNameNr_sip_simplewrapper,
    0,
    slots_QGLFormat_OpenGLVersionFlags,
    init_type_QGLFormat_OpenGLVersionFlags,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QGLFormat_OpenGLVersionFlags,
    assign_QGLFormat_OpenGLVersionFlags,
    array_QGLFormat_OpenGLVersionFlags,
    copy_QGLFormat_OpenGLVersionFlags,
    release_QGLFormat_OpenGLVersionFlags,
    0,
    convertTo_QGLFormat_OpenGLVersionFlags,
    0,
    0,
    0,
    0,
    0
};

#line 70 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qgl.sip"
#include <qgl.h>
#line 17820 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qgl.sip"
#include <qgl.h>
#line 17824 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
#line 70 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qgl.sip"
#include <qgl.h>
#line 17827 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"


PyDoc_STRVAR(doc_QGLFormat_setDepthBufferSize, "setDepthBufferSize(self, int)");

extern "C" {static PyObject *meth_QGLFormat_setDepthBufferSize(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_setDepthBufferSize(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
         ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QGLFormat, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setDepthBufferSize(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_setDepthBufferSize, doc_QGLFormat_setDepthBufferSize);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_depthBufferSize, "depthBufferSize(self) -> int");

extern "C" {static PyObject *meth_QGLFormat_depthBufferSize(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_depthBufferSize(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLFormat, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->depthBufferSize();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_depthBufferSize, doc_QGLFormat_depthBufferSize);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_setAccumBufferSize, "setAccumBufferSize(self, int)");

extern "C" {static PyObject *meth_QGLFormat_setAccumBufferSize(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_setAccumBufferSize(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
         ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QGLFormat, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setAccumBufferSize(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_setAccumBufferSize, doc_QGLFormat_setAccumBufferSize);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_accumBufferSize, "accumBufferSize(self) -> int");

extern "C" {static PyObject *meth_QGLFormat_accumBufferSize(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_accumBufferSize(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLFormat, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->accumBufferSize();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_accumBufferSize, doc_QGLFormat_accumBufferSize);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_setAlphaBufferSize, "setAlphaBufferSize(self, int)");

extern "C" {static PyObject *meth_QGLFormat_setAlphaBufferSize(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_setAlphaBufferSize(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
         ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QGLFormat, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setAlphaBufferSize(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_setAlphaBufferSize, doc_QGLFormat_setAlphaBufferSize);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_alphaBufferSize, "alphaBufferSize(self) -> int");

extern "C" {static PyObject *meth_QGLFormat_alphaBufferSize(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_alphaBufferSize(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLFormat, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->alphaBufferSize();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_alphaBufferSize, doc_QGLFormat_alphaBufferSize);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_setStencilBufferSize, "setStencilBufferSize(self, int)");

extern "C" {static PyObject *meth_QGLFormat_setStencilBufferSize(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_setStencilBufferSize(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
         ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QGLFormat, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setStencilBufferSize(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_setStencilBufferSize, doc_QGLFormat_setStencilBufferSize);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_stencilBufferSize, "stencilBufferSize(self) -> int");

extern "C" {static PyObject *meth_QGLFormat_stencilBufferSize(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_stencilBufferSize(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLFormat, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->stencilBufferSize();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_stencilBufferSize, doc_QGLFormat_stencilBufferSize);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_setSampleBuffers, "setSampleBuffers(self, bool)");

extern "C" {static PyObject *meth_QGLFormat_setSampleBuffers(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_setSampleBuffers(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        bool a0;
         ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bb", &sipSelf, sipType_QGLFormat, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setSampleBuffers(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_setSampleBuffers, doc_QGLFormat_setSampleBuffers);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_setSamples, "setSamples(self, int)");

extern "C" {static PyObject *meth_QGLFormat_setSamples(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_setSamples(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
         ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QGLFormat, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setSamples(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_setSamples, doc_QGLFormat_setSamples);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_samples, "samples(self) -> int");

extern "C" {static PyObject *meth_QGLFormat_samples(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_samples(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLFormat, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->samples();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_samples, doc_QGLFormat_samples);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_setDoubleBuffer, "setDoubleBuffer(self, bool)");

extern "C" {static PyObject *meth_QGLFormat_setDoubleBuffer(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_setDoubleBuffer(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        bool a0;
         ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bb", &sipSelf, sipType_QGLFormat, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setDoubleBuffer(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_setDoubleBuffer, doc_QGLFormat_setDoubleBuffer);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_setDepth, "setDepth(self, bool)");

extern "C" {static PyObject *meth_QGLFormat_setDepth(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_setDepth(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        bool a0;
         ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bb", &sipSelf, sipType_QGLFormat, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setDepth(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_setDepth, doc_QGLFormat_setDepth);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_setRgba, "setRgba(self, bool)");

extern "C" {static PyObject *meth_QGLFormat_setRgba(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_setRgba(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        bool a0;
         ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bb", &sipSelf, sipType_QGLFormat, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setRgba(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_setRgba, doc_QGLFormat_setRgba);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_setAlpha, "setAlpha(self, bool)");

extern "C" {static PyObject *meth_QGLFormat_setAlpha(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_setAlpha(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        bool a0;
         ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bb", &sipSelf, sipType_QGLFormat, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setAlpha(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_setAlpha, doc_QGLFormat_setAlpha);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_setAccum, "setAccum(self, bool)");

extern "C" {static PyObject *meth_QGLFormat_setAccum(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_setAccum(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        bool a0;
         ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bb", &sipSelf, sipType_QGLFormat, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setAccum(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_setAccum, doc_QGLFormat_setAccum);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_setStencil, "setStencil(self, bool)");

extern "C" {static PyObject *meth_QGLFormat_setStencil(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_setStencil(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        bool a0;
         ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bb", &sipSelf, sipType_QGLFormat, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setStencil(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_setStencil, doc_QGLFormat_setStencil);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_setStereo, "setStereo(self, bool)");

extern "C" {static PyObject *meth_QGLFormat_setStereo(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_setStereo(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        bool a0;
         ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bb", &sipSelf, sipType_QGLFormat, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setStereo(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_setStereo, doc_QGLFormat_setStereo);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_setDirectRendering, "setDirectRendering(self, bool)");

extern "C" {static PyObject *meth_QGLFormat_setDirectRendering(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_setDirectRendering(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        bool a0;
         ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bb", &sipSelf, sipType_QGLFormat, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setDirectRendering(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_setDirectRendering, doc_QGLFormat_setDirectRendering);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_setOverlay, "setOverlay(self, bool)");

extern "C" {static PyObject *meth_QGLFormat_setOverlay(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_setOverlay(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        bool a0;
         ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bb", &sipSelf, sipType_QGLFormat, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setOverlay(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_setOverlay, doc_QGLFormat_setOverlay);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_plane, "plane(self) -> int");

extern "C" {static PyObject *meth_QGLFormat_plane(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_plane(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLFormat, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->plane();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_plane, doc_QGLFormat_plane);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_setPlane, "setPlane(self, int)");

extern "C" {static PyObject *meth_QGLFormat_setPlane(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_setPlane(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
         ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QGLFormat, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setPlane(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_setPlane, doc_QGLFormat_setPlane);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_setOption, "setOption(self, Union[QGL.FormatOptions, QGL.FormatOption])");

extern "C" {static PyObject *meth_QGLFormat_setOption(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_setOption(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGL::FormatOptions* a0;
        int a0State = 0;
         ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QGLFormat, &sipCpp, sipType_QGL_FormatOptions, &a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setOption(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(a0,sipType_QGL_FormatOptions,a0State);

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_setOption, doc_QGLFormat_setOption);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_testOption, "testOption(self, Union[QGL.FormatOptions, QGL.FormatOption]) -> bool");

extern "C" {static PyObject *meth_QGLFormat_testOption(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_testOption(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGL::FormatOptions* a0;
        int a0State = 0;
        const  ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BJ1", &sipSelf, sipType_QGLFormat, &sipCpp, sipType_QGL_FormatOptions, &a0, &a0State))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->testOption(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(a0,sipType_QGL_FormatOptions,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_testOption, doc_QGLFormat_testOption);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_defaultFormat, "defaultFormat() -> QGLFormat");

extern "C" {static PyObject *meth_QGLFormat_defaultFormat(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_defaultFormat(PyObject *, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        if (sipParseArgs(&sipParseErr, sipArgs, ""))
        {
             ::QGLFormat*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QGLFormat( ::QGLFormat::defaultFormat());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QGLFormat,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_defaultFormat, doc_QGLFormat_defaultFormat);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_setDefaultFormat, "setDefaultFormat(QGLFormat)");

extern "C" {static PyObject *meth_QGLFormat_setDefaultFormat(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_setDefaultFormat(PyObject *, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFormat* a0;

        if (sipParseArgs(&sipParseErr, sipArgs, "J9", sipType_QGLFormat, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
             ::QGLFormat::setDefaultFormat(*a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_setDefaultFormat, doc_QGLFormat_setDefaultFormat);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_defaultOverlayFormat, "defaultOverlayFormat() -> QGLFormat");

extern "C" {static PyObject *meth_QGLFormat_defaultOverlayFormat(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_defaultOverlayFormat(PyObject *, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        if (sipParseArgs(&sipParseErr, sipArgs, ""))
        {
             ::QGLFormat*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QGLFormat( ::QGLFormat::defaultOverlayFormat());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QGLFormat,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_defaultOverlayFormat, doc_QGLFormat_defaultOverlayFormat);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_setDefaultOverlayFormat, "setDefaultOverlayFormat(QGLFormat)");

extern "C" {static PyObject *meth_QGLFormat_setDefaultOverlayFormat(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_setDefaultOverlayFormat(PyObject *, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFormat* a0;

        if (sipParseArgs(&sipParseErr, sipArgs, "J9", sipType_QGLFormat, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
             ::QGLFormat::setDefaultOverlayFormat(*a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_setDefaultOverlayFormat, doc_QGLFormat_setDefaultOverlayFormat);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_hasOpenGL, "hasOpenGL() -> bool");

extern "C" {static PyObject *meth_QGLFormat_hasOpenGL(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_hasOpenGL(PyObject *, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        if (sipParseArgs(&sipParseErr, sipArgs, ""))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes =  ::QGLFormat::hasOpenGL();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_hasOpenGL, doc_QGLFormat_hasOpenGL);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_hasOpenGLOverlays, "hasOpenGLOverlays() -> bool");

extern "C" {static PyObject *meth_QGLFormat_hasOpenGLOverlays(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_hasOpenGLOverlays(PyObject *, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        if (sipParseArgs(&sipParseErr, sipArgs, ""))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes =  ::QGLFormat::hasOpenGLOverlays();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_hasOpenGLOverlays, doc_QGLFormat_hasOpenGLOverlays);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_doubleBuffer, "doubleBuffer(self) -> bool");

extern "C" {static PyObject *meth_QGLFormat_doubleBuffer(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_doubleBuffer(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLFormat, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->doubleBuffer();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_doubleBuffer, doc_QGLFormat_doubleBuffer);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_depth, "depth(self) -> bool");

extern "C" {static PyObject *meth_QGLFormat_depth(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_depth(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLFormat, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->depth();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_depth, doc_QGLFormat_depth);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_rgba, "rgba(self) -> bool");

extern "C" {static PyObject *meth_QGLFormat_rgba(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_rgba(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLFormat, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->rgba();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_rgba, doc_QGLFormat_rgba);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_alpha, "alpha(self) -> bool");

extern "C" {static PyObject *meth_QGLFormat_alpha(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_alpha(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLFormat, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->alpha();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_alpha, doc_QGLFormat_alpha);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_accum, "accum(self) -> bool");

extern "C" {static PyObject *meth_QGLFormat_accum(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_accum(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLFormat, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->accum();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_accum, doc_QGLFormat_accum);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_stencil, "stencil(self) -> bool");

extern "C" {static PyObject *meth_QGLFormat_stencil(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_stencil(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLFormat, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->stencil();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_stencil, doc_QGLFormat_stencil);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_stereo, "stereo(self) -> bool");

extern "C" {static PyObject *meth_QGLFormat_stereo(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_stereo(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLFormat, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->stereo();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_stereo, doc_QGLFormat_stereo);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_directRendering, "directRendering(self) -> bool");

extern "C" {static PyObject *meth_QGLFormat_directRendering(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_directRendering(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLFormat, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->directRendering();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_directRendering, doc_QGLFormat_directRendering);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_hasOverlay, "hasOverlay(self) -> bool");

extern "C" {static PyObject *meth_QGLFormat_hasOverlay(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_hasOverlay(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLFormat, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->hasOverlay();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_hasOverlay, doc_QGLFormat_hasOverlay);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_sampleBuffers, "sampleBuffers(self) -> bool");

extern "C" {static PyObject *meth_QGLFormat_sampleBuffers(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_sampleBuffers(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLFormat, &sipCpp))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->sampleBuffers();
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_sampleBuffers, doc_QGLFormat_sampleBuffers);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_setRedBufferSize, "setRedBufferSize(self, int)");

extern "C" {static PyObject *meth_QGLFormat_setRedBufferSize(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_setRedBufferSize(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
         ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QGLFormat, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setRedBufferSize(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_setRedBufferSize, doc_QGLFormat_setRedBufferSize);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_redBufferSize, "redBufferSize(self) -> int");

extern "C" {static PyObject *meth_QGLFormat_redBufferSize(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_redBufferSize(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLFormat, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->redBufferSize();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_redBufferSize, doc_QGLFormat_redBufferSize);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_setGreenBufferSize, "setGreenBufferSize(self, int)");

extern "C" {static PyObject *meth_QGLFormat_setGreenBufferSize(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_setGreenBufferSize(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
         ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QGLFormat, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setGreenBufferSize(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_setGreenBufferSize, doc_QGLFormat_setGreenBufferSize);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_greenBufferSize, "greenBufferSize(self) -> int");

extern "C" {static PyObject *meth_QGLFormat_greenBufferSize(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_greenBufferSize(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLFormat, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->greenBufferSize();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_greenBufferSize, doc_QGLFormat_greenBufferSize);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_setBlueBufferSize, "setBlueBufferSize(self, int)");

extern "C" {static PyObject *meth_QGLFormat_setBlueBufferSize(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_setBlueBufferSize(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
         ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QGLFormat, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setBlueBufferSize(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_setBlueBufferSize, doc_QGLFormat_setBlueBufferSize);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_blueBufferSize, "blueBufferSize(self) -> int");

extern "C" {static PyObject *meth_QGLFormat_blueBufferSize(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_blueBufferSize(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLFormat, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->blueBufferSize();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_blueBufferSize, doc_QGLFormat_blueBufferSize);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_setSwapInterval, "setSwapInterval(self, int)");

extern "C" {static PyObject *meth_QGLFormat_setSwapInterval(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_setSwapInterval(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
         ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bi", &sipSelf, sipType_QGLFormat, &sipCpp, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setSwapInterval(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_setSwapInterval, doc_QGLFormat_setSwapInterval);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_swapInterval, "swapInterval(self) -> int");

extern "C" {static PyObject *meth_QGLFormat_swapInterval(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_swapInterval(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLFormat, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->swapInterval();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_swapInterval, doc_QGLFormat_swapInterval);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_openGLVersionFlags, "openGLVersionFlags() -> QGLFormat.OpenGLVersionFlags");

extern "C" {static PyObject *meth_QGLFormat_openGLVersionFlags(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_openGLVersionFlags(PyObject *, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        if (sipParseArgs(&sipParseErr, sipArgs, ""))
        {
             ::QGLFormat::OpenGLVersionFlags*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QGLFormat::OpenGLVersionFlags( ::QGLFormat::openGLVersionFlags());
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QGLFormat_OpenGLVersionFlags,NULL);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_openGLVersionFlags, doc_QGLFormat_openGLVersionFlags);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_setVersion, "setVersion(self, int, int)");

extern "C" {static PyObject *meth_QGLFormat_setVersion(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_setVersion(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        int a0;
        int a1;
         ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "Bii", &sipSelf, sipType_QGLFormat, &sipCpp, &a0, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setVersion(a0,a1);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_setVersion, doc_QGLFormat_setVersion);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_majorVersion, "majorVersion(self) -> int");

extern "C" {static PyObject *meth_QGLFormat_majorVersion(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_majorVersion(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLFormat, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->majorVersion();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_majorVersion, doc_QGLFormat_majorVersion);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_minorVersion, "minorVersion(self) -> int");

extern "C" {static PyObject *meth_QGLFormat_minorVersion(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_minorVersion(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLFormat, &sipCpp))
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->minorVersion();
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_minorVersion, doc_QGLFormat_minorVersion);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_setProfile, "setProfile(self, QGLFormat.OpenGLContextProfile)");

extern "C" {static PyObject *meth_QGLFormat_setProfile(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_setProfile(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGLFormat::OpenGLContextProfile a0;
         ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "BE", &sipSelf, sipType_QGLFormat, &sipCpp, sipType_QGLFormat_OpenGLContextProfile, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp->setProfile(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_setProfile, doc_QGLFormat_setProfile);

    return NULL;
}


PyDoc_STRVAR(doc_QGLFormat_profile, "profile(self) -> QGLFormat.OpenGLContextProfile");

extern "C" {static PyObject *meth_QGLFormat_profile(PyObject *, PyObject *);}
static PyObject *meth_QGLFormat_profile(PyObject *sipSelf, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFormat *sipCpp;

        if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QGLFormat, &sipCpp))
        {
             ::QGLFormat::OpenGLContextProfile sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = sipCpp->profile();
            Py_END_ALLOW_THREADS

            return sipConvertFromEnum(static_cast<int>(sipRes), sipType_QGLFormat_OpenGLContextProfile);
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoMethod(sipParseErr, sipName_QGLFormat, sipName_profile, doc_QGLFormat_profile);

    return NULL;
}


extern "C" {static PyObject *slot_QGLFormat___eq__(PyObject *,PyObject *);}
static PyObject *slot_QGLFormat___eq__(PyObject *sipSelf,PyObject *sipArg)
{
     ::QGLFormat *sipCpp = reinterpret_cast< ::QGLFormat *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGLFormat));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFormat* a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J9", sipType_QGLFormat, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = operator==((*sipCpp), *a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtOpenGL, eq_slot, sipType_QGLFormat, sipSelf, sipArg);
}


extern "C" {static PyObject *slot_QGLFormat___ne__(PyObject *,PyObject *);}
static PyObject *slot_QGLFormat___ne__(PyObject *sipSelf,PyObject *sipArg)
{
     ::QGLFormat *sipCpp = reinterpret_cast< ::QGLFormat *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGLFormat));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const  ::QGLFormat* a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J9", sipType_QGLFormat, &a0))
        {
            bool sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = operator!=((*sipCpp), *a0);
            Py_END_ALLOW_THREADS

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtOpenGL, ne_slot, sipType_QGLFormat, sipSelf, sipArg);
}


/* Call the instance's destructor. */
extern "C" {static void release_QGLFormat(void *, int);}
static void release_QGLFormat(void *sipCppV, int)
{
    Py_BEGIN_ALLOW_THREADS

    delete reinterpret_cast< ::QGLFormat *>(sipCppV);

    Py_END_ALLOW_THREADS
}


extern "C" {static void assign_QGLFormat(void *, SIP_SSIZE_T, void *);}
static void assign_QGLFormat(void *sipDst, SIP_SSIZE_T sipDstIdx, void *sipSrc)
{
    reinterpret_cast< ::QGLFormat *>(sipDst)[sipDstIdx] = *reinterpret_cast< ::QGLFormat *>(sipSrc);
}


extern "C" {static void *array_QGLFormat(SIP_SSIZE_T);}
static void *array_QGLFormat(SIP_SSIZE_T sipNrElem)
{
    return new  ::QGLFormat[sipNrElem];
}


extern "C" {static void *copy_QGLFormat(const void *, SIP_SSIZE_T);}
static void *copy_QGLFormat(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new  ::QGLFormat(reinterpret_cast<const  ::QGLFormat *>(sipSrc)[sipSrcIdx]);
}


extern "C" {static void dealloc_QGLFormat(sipSimpleWrapper *);}
static void dealloc_QGLFormat(sipSimpleWrapper *sipSelf)
{
    if (sipIsOwnedByPython(sipSelf))
    {
        release_QGLFormat(sipGetAddress(sipSelf), 0);
    }
}


extern "C" {static void *init_type_QGLFormat(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QGLFormat(sipSimpleWrapper *, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
     ::QGLFormat *sipCpp = 0;

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new  ::QGLFormat();
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    {
         ::QGL::FormatOptions* a0;
        int a0State = 0;
        int a1 = 0;

        static const char *sipKwdList[] = {
            NULL,
            sipName_plane,
        };

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, sipKwdList, sipUnused, "J1|i", sipType_QGL_FormatOptions, &a0, &a0State, &a1))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new  ::QGLFormat(*a0,a1);
            Py_END_ALLOW_THREADS
            sipReleaseType(a0,sipType_QGL_FormatOptions,a0State);

            return sipCpp;
        }
    }

    {
        const  ::QGLFormat* a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J9", sipType_QGLFormat, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new  ::QGLFormat(*a0);
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    return NULL;
}


/* Define this type's Python slots. */
static sipPySlotDef slots_QGLFormat[] = {
    {(void *)slot_QGLFormat___eq__, eq_slot},
    {(void *)slot_QGLFormat___ne__, ne_slot},
    {0, (sipPySlotType)0}
};


static PyMethodDef methods_QGLFormat[] = {
    {SIP_MLNAME_CAST(sipName_accum), meth_QGLFormat_accum, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_accum)},
    {SIP_MLNAME_CAST(sipName_accumBufferSize), meth_QGLFormat_accumBufferSize, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_accumBufferSize)},
    {SIP_MLNAME_CAST(sipName_alpha), meth_QGLFormat_alpha, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_alpha)},
    {SIP_MLNAME_CAST(sipName_alphaBufferSize), meth_QGLFormat_alphaBufferSize, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_alphaBufferSize)},
    {SIP_MLNAME_CAST(sipName_blueBufferSize), meth_QGLFormat_blueBufferSize, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_blueBufferSize)},
    {SIP_MLNAME_CAST(sipName_defaultFormat), meth_QGLFormat_defaultFormat, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_defaultFormat)},
    {SIP_MLNAME_CAST(sipName_defaultOverlayFormat), meth_QGLFormat_defaultOverlayFormat, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_defaultOverlayFormat)},
    {SIP_MLNAME_CAST(sipName_depth), meth_QGLFormat_depth, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_depth)},
    {SIP_MLNAME_CAST(sipName_depthBufferSize), meth_QGLFormat_depthBufferSize, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_depthBufferSize)},
    {SIP_MLNAME_CAST(sipName_directRendering), meth_QGLFormat_directRendering, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_directRendering)},
    {SIP_MLNAME_CAST(sipName_doubleBuffer), meth_QGLFormat_doubleBuffer, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_doubleBuffer)},
    {SIP_MLNAME_CAST(sipName_greenBufferSize), meth_QGLFormat_greenBufferSize, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_greenBufferSize)},
    {SIP_MLNAME_CAST(sipName_hasOpenGL), meth_QGLFormat_hasOpenGL, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_hasOpenGL)},
    {SIP_MLNAME_CAST(sipName_hasOpenGLOverlays), meth_QGLFormat_hasOpenGLOverlays, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_hasOpenGLOverlays)},
    {SIP_MLNAME_CAST(sipName_hasOverlay), meth_QGLFormat_hasOverlay, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_hasOverlay)},
    {SIP_MLNAME_CAST(sipName_majorVersion), meth_QGLFormat_majorVersion, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_majorVersion)},
    {SIP_MLNAME_CAST(sipName_minorVersion), meth_QGLFormat_minorVersion, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_minorVersion)},
    {SIP_MLNAME_CAST(sipName_openGLVersionFlags), meth_QGLFormat_openGLVersionFlags, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_openGLVersionFlags)},
    {SIP_MLNAME_CAST(sipName_plane), meth_QGLFormat_plane, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_plane)},
    {SIP_MLNAME_CAST(sipName_profile), meth_QGLFormat_profile, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_profile)},
    {SIP_MLNAME_CAST(sipName_redBufferSize), meth_QGLFormat_redBufferSize, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_redBufferSize)},
    {SIP_MLNAME_CAST(sipName_rgba), meth_QGLFormat_rgba, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_rgba)},
    {SIP_MLNAME_CAST(sipName_sampleBuffers), meth_QGLFormat_sampleBuffers, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_sampleBuffers)},
    {SIP_MLNAME_CAST(sipName_samples), meth_QGLFormat_samples, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_samples)},
    {SIP_MLNAME_CAST(sipName_setAccum), meth_QGLFormat_setAccum, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_setAccum)},
    {SIP_MLNAME_CAST(sipName_setAccumBufferSize), meth_QGLFormat_setAccumBufferSize, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_setAccumBufferSize)},
    {SIP_MLNAME_CAST(sipName_setAlpha), meth_QGLFormat_setAlpha, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_setAlpha)},
    {SIP_MLNAME_CAST(sipName_setAlphaBufferSize), meth_QGLFormat_setAlphaBufferSize, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_setAlphaBufferSize)},
    {SIP_MLNAME_CAST(sipName_setBlueBufferSize), meth_QGLFormat_setBlueBufferSize, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_setBlueBufferSize)},
    {SIP_MLNAME_CAST(sipName_setDefaultFormat), meth_QGLFormat_setDefaultFormat, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_setDefaultFormat)},
    {SIP_MLNAME_CAST(sipName_setDefaultOverlayFormat), meth_QGLFormat_setDefaultOverlayFormat, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_setDefaultOverlayFormat)},
    {SIP_MLNAME_CAST(sipName_setDepth), meth_QGLFormat_setDepth, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_setDepth)},
    {SIP_MLNAME_CAST(sipName_setDepthBufferSize), meth_QGLFormat_setDepthBufferSize, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_setDepthBufferSize)},
    {SIP_MLNAME_CAST(sipName_setDirectRendering), meth_QGLFormat_setDirectRendering, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_setDirectRendering)},
    {SIP_MLNAME_CAST(sipName_setDoubleBuffer), meth_QGLFormat_setDoubleBuffer, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_setDoubleBuffer)},
    {SIP_MLNAME_CAST(sipName_setGreenBufferSize), meth_QGLFormat_setGreenBufferSize, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_setGreenBufferSize)},
    {SIP_MLNAME_CAST(sipName_setOption), meth_QGLFormat_setOption, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_setOption)},
    {SIP_MLNAME_CAST(sipName_setOverlay), meth_QGLFormat_setOverlay, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_setOverlay)},
    {SIP_MLNAME_CAST(sipName_setPlane), meth_QGLFormat_setPlane, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_setPlane)},
    {SIP_MLNAME_CAST(sipName_setProfile), meth_QGLFormat_setProfile, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_setProfile)},
    {SIP_MLNAME_CAST(sipName_setRedBufferSize), meth_QGLFormat_setRedBufferSize, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_setRedBufferSize)},
    {SIP_MLNAME_CAST(sipName_setRgba), meth_QGLFormat_setRgba, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_setRgba)},
    {SIP_MLNAME_CAST(sipName_setSampleBuffers), meth_QGLFormat_setSampleBuffers, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_setSampleBuffers)},
    {SIP_MLNAME_CAST(sipName_setSamples), meth_QGLFormat_setSamples, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_setSamples)},
    {SIP_MLNAME_CAST(sipName_setStencil), meth_QGLFormat_setStencil, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_setStencil)},
    {SIP_MLNAME_CAST(sipName_setStencilBufferSize), meth_QGLFormat_setStencilBufferSize, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_setStencilBufferSize)},
    {SIP_MLNAME_CAST(sipName_setStereo), meth_QGLFormat_setStereo, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_setStereo)},
    {SIP_MLNAME_CAST(sipName_setSwapInterval), meth_QGLFormat_setSwapInterval, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_setSwapInterval)},
    {SIP_MLNAME_CAST(sipName_setVersion), meth_QGLFormat_setVersion, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_setVersion)},
    {SIP_MLNAME_CAST(sipName_stencil), meth_QGLFormat_stencil, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_stencil)},
    {SIP_MLNAME_CAST(sipName_stencilBufferSize), meth_QGLFormat_stencilBufferSize, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_stencilBufferSize)},
    {SIP_MLNAME_CAST(sipName_stereo), meth_QGLFormat_stereo, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_stereo)},
    {SIP_MLNAME_CAST(sipName_swapInterval), meth_QGLFormat_swapInterval, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_swapInterval)},
    {SIP_MLNAME_CAST(sipName_testOption), meth_QGLFormat_testOption, METH_VARARGS, SIP_MLDOC_CAST(doc_QGLFormat_testOption)}
};

static sipEnumMemberDef enummembers_QGLFormat[] = {
    {sipName_CompatibilityProfile, static_cast<int>( ::QGLFormat::CompatibilityProfile), 12},
    {sipName_CoreProfile, static_cast<int>( ::QGLFormat::CoreProfile), 12},
    {sipName_NoProfile, static_cast<int>( ::QGLFormat::NoProfile), 12},
    {sipName_OpenGL_ES_CommonLite_Version_1_0, static_cast<int>( ::QGLFormat::OpenGL_ES_CommonLite_Version_1_0), 13},
    {sipName_OpenGL_ES_CommonLite_Version_1_1, static_cast<int>( ::QGLFormat::OpenGL_ES_CommonLite_Version_1_1), 13},
    {sipName_OpenGL_ES_Common_Version_1_0, static_cast<int>( ::QGLFormat::OpenGL_ES_Common_Version_1_0), 13},
    {sipName_OpenGL_ES_Common_Version_1_1, static_cast<int>( ::QGLFormat::OpenGL_ES_Common_Version_1_1), 13},
    {sipName_OpenGL_ES_Version_2_0, static_cast<int>( ::QGLFormat::OpenGL_ES_Version_2_0), 13},
    {sipName_OpenGL_Version_1_1, static_cast<int>( ::QGLFormat::OpenGL_Version_1_1), 13},
    {sipName_OpenGL_Version_1_2, static_cast<int>( ::QGLFormat::OpenGL_Version_1_2), 13},
    {sipName_OpenGL_Version_1_3, static_cast<int>( ::QGLFormat::OpenGL_Version_1_3), 13},
    {sipName_OpenGL_Version_1_4, static_cast<int>( ::QGLFormat::OpenGL_Version_1_4), 13},
    {sipName_OpenGL_Version_1_5, static_cast<int>( ::QGLFormat::OpenGL_Version_1_5), 13},
    {sipName_OpenGL_Version_2_0, static_cast<int>( ::QGLFormat::OpenGL_Version_2_0), 13},
    {sipName_OpenGL_Version_2_1, static_cast<int>( ::QGLFormat::OpenGL_Version_2_1), 13},
    {sipName_OpenGL_Version_3_0, static_cast<int>( ::QGLFormat::OpenGL_Version_3_0), 13},
    {sipName_OpenGL_Version_3_1, static_cast<int>( ::QGLFormat::OpenGL_Version_3_1), 13},
    {sipName_OpenGL_Version_3_2, static_cast<int>( ::QGLFormat::OpenGL_Version_3_2), 13},
    {sipName_OpenGL_Version_3_3, static_cast<int>( ::QGLFormat::OpenGL_Version_3_3), 13},
    {sipName_OpenGL_Version_4_0, static_cast<int>( ::QGLFormat::OpenGL_Version_4_0), 13},
    {sipName_OpenGL_Version_None, static_cast<int>( ::QGLFormat::OpenGL_Version_None), 13},
};

PyDoc_STRVAR(doc_QGLFormat, "\1QGLFormat()\n"
"QGLFormat(Union[QGL.FormatOptions, QGL.FormatOption], plane: int = 0)\n"
"QGLFormat(QGLFormat)");


static pyqt4ClassPluginDef plugin_QGLFormat = {
    0,
    0,
    0
};


sipClassTypeDef sipTypeDef_QtOpenGL_QGLFormat = {
    {
        -1,
        0,
        0,
        SIP_TYPE_CLASS,
        sipNameNr_QGLFormat,
        {0},
        &plugin_QGLFormat
    },
    {
        sipNameNr_QGLFormat,
        {0, 0, 1},
        54, methods_QGLFormat,
        21, enummembers_QGLFormat,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QGLFormat,
    sipNameNr_PyQt4_QtCore_pyqtWrapperType,
    sipNameNr_sip_simplewrapper,
    0,
    slots_QGLFormat,
    init_type_QGLFormat,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QGLFormat,
    assign_QGLFormat,
    array_QGLFormat,
    copy_QGLFormat,
    release_QGLFormat,
    0,
    0,
    0,
    0,
    0,
    0,
    0
};

#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qgl.sip"
#include <qgl.h>
#line 19764 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qgl.sip"
#include <qgl.h>
#line 19768 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"


extern "C" {static int slot_QGL_FormatOptions___bool__(PyObject *);}
static int slot_QGL_FormatOptions___bool__(PyObject *sipSelf)
{
     ::QGL::FormatOptions *sipCpp = reinterpret_cast< ::QGL::FormatOptions *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGL_FormatOptions));

    if (!sipCpp)
        return -1;


    {
        {
            int sipRes = 0;

#line 381 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qglobal.sip"
#if QT_VERSION >= 0x050000
        sipRes = (sipCpp->operator QGL::FormatOptions::Int() != 0);
#else
        sipRes = (sipCpp->operator int() != 0);
#endif
#line 19790 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

            return sipRes;
        }
    }

    return 0;
}


extern "C" {static PyObject *slot_QGL_FormatOptions___ne__(PyObject *,PyObject *);}
static PyObject *slot_QGL_FormatOptions___ne__(PyObject *sipSelf,PyObject *sipArg)
{
     ::QGL::FormatOptions *sipCpp = reinterpret_cast< ::QGL::FormatOptions *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGL_FormatOptions));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const  ::QGL::FormatOptions* a0;
        int a0State = 0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J1", sipType_QGL_FormatOptions, &a0, &a0State))
        {
            bool sipRes = 0;

#line 372 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qglobal.sip"
#if QT_VERSION >= 0x050000
        sipRes = (sipCpp->operator QGL::FormatOptions::Int() != a0->operator QGL::FormatOptions::Int());
#else
        sipRes = (sipCpp->operator int() != a0->operator int());
#endif
#line 19824 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
            sipReleaseType(const_cast< ::QGL::FormatOptions *>(a0),sipType_QGL_FormatOptions,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtOpenGL, ne_slot, sipType_QGL_FormatOptions, sipSelf, sipArg);
}


extern "C" {static PyObject *slot_QGL_FormatOptions___eq__(PyObject *,PyObject *);}
static PyObject *slot_QGL_FormatOptions___eq__(PyObject *sipSelf,PyObject *sipArg)
{
     ::QGL::FormatOptions *sipCpp = reinterpret_cast< ::QGL::FormatOptions *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGL_FormatOptions));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        const  ::QGL::FormatOptions* a0;
        int a0State = 0;

        if (sipParseArgs(&sipParseErr, sipArg, "1J1", sipType_QGL_FormatOptions, &a0, &a0State))
        {
            bool sipRes = 0;

#line 363 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qglobal.sip"
#if QT_VERSION >= 0x050000
        sipRes = (sipCpp->operator QGL::FormatOptions::Int() == a0->operator QGL::FormatOptions::Int());
#else
        sipRes = (sipCpp->operator int() == a0->operator int());
#endif
#line 19864 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
            sipReleaseType(const_cast< ::QGL::FormatOptions *>(a0),sipType_QGL_FormatOptions,a0State);

            return PyBool_FromLong(sipRes);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtOpenGL, eq_slot, sipType_QGL_FormatOptions, sipSelf, sipArg);
}


extern "C" {static PyObject *slot_QGL_FormatOptions___ixor__(PyObject *,PyObject *);}
static PyObject *slot_QGL_FormatOptions___ixor__(PyObject *sipSelf,PyObject *sipArg)
{
    if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QGL_FormatOptions)))
    {
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    }

     ::QGL::FormatOptions *sipCpp = reinterpret_cast< ::QGL::FormatOptions *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGL_FormatOptions));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        int a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1i", &a0))
        {
#line 357 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qglobal.sip"
        *sipCpp = QGL::FormatOptions(*sipCpp ^ a0);
#line 19903 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

            Py_INCREF(sipSelf);
            return sipSelf;
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    PyErr_Clear();

    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}


extern "C" {static PyObject *slot_QGL_FormatOptions___xor__(PyObject *,PyObject *);}
static PyObject *slot_QGL_FormatOptions___xor__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGL::FormatOptions* a0;
        int a0State = 0;
        int a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J1i", sipType_QGL_FormatOptions, &a0, &a0State, &a1))
        {
             ::QGL::FormatOptions*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QGL::FormatOptions((*a0 ^ a1));
            Py_END_ALLOW_THREADS
            sipReleaseType(a0,sipType_QGL_FormatOptions,a0State);

            return sipConvertFromNewType(sipRes,sipType_QGL_FormatOptions,NULL);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtOpenGL, xor_slot, NULL, sipArg0, sipArg1);
}


extern "C" {static PyObject *slot_QGL_FormatOptions___ior__(PyObject *,PyObject *);}
static PyObject *slot_QGL_FormatOptions___ior__(PyObject *sipSelf,PyObject *sipArg)
{
    if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QGL_FormatOptions)))
    {
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    }

     ::QGL::FormatOptions *sipCpp = reinterpret_cast< ::QGL::FormatOptions *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGL_FormatOptions));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        int a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1i", &a0))
        {
#line 351 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qglobal.sip"
        *sipCpp = QGL::FormatOptions(*sipCpp | a0);
#line 19977 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

            Py_INCREF(sipSelf);
            return sipSelf;
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    PyErr_Clear();

    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}


extern "C" {static PyObject *slot_QGL_FormatOptions___or__(PyObject *,PyObject *);}
static PyObject *slot_QGL_FormatOptions___or__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGL::FormatOptions* a0;
        int a0State = 0;
        int a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J1i", sipType_QGL_FormatOptions, &a0, &a0State, &a1))
        {
             ::QGL::FormatOptions*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QGL::FormatOptions((*a0 | a1));
            Py_END_ALLOW_THREADS
            sipReleaseType(a0,sipType_QGL_FormatOptions,a0State);

            return sipConvertFromNewType(sipRes,sipType_QGL_FormatOptions,NULL);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtOpenGL, or_slot, NULL, sipArg0, sipArg1);
}


extern "C" {static PyObject *slot_QGL_FormatOptions___iand__(PyObject *,PyObject *);}
static PyObject *slot_QGL_FormatOptions___iand__(PyObject *sipSelf,PyObject *sipArg)
{
    if (!PyObject_TypeCheck(sipSelf, sipTypeAsPyTypeObject(sipType_QGL_FormatOptions)))
    {
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    }

     ::QGL::FormatOptions *sipCpp = reinterpret_cast< ::QGL::FormatOptions *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGL_FormatOptions));

    if (!sipCpp)
        return 0;

    PyObject *sipParseErr = NULL;

    {
        int a0;

        if (sipParseArgs(&sipParseErr, sipArg, "1i", &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp-> ::QGL::FormatOptions::operator&=(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(sipSelf);
            return sipSelf;
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    PyErr_Clear();

    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
}


extern "C" {static PyObject *slot_QGL_FormatOptions___and__(PyObject *,PyObject *);}
static PyObject *slot_QGL_FormatOptions___and__(PyObject *sipArg0,PyObject *sipArg1)
{
    PyObject *sipParseErr = NULL;

    {
         ::QGL::FormatOptions* a0;
        int a0State = 0;
        int a1;

        if (sipParsePair(&sipParseErr, sipArg0, sipArg1, "J1i", sipType_QGL_FormatOptions, &a0, &a0State, &a1))
        {
             ::QGL::FormatOptions*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QGL::FormatOptions((*a0 & a1));
            Py_END_ALLOW_THREADS
            sipReleaseType(a0,sipType_QGL_FormatOptions,a0State);

            return sipConvertFromNewType(sipRes,sipType_QGL_FormatOptions,NULL);
        }
    }

    Py_XDECREF(sipParseErr);

    if (sipParseErr == Py_None)
        return NULL;

    return sipPySlotExtend(&sipModuleAPI_QtOpenGL, and_slot, NULL, sipArg0, sipArg1);
}


extern "C" {static PyObject *slot_QGL_FormatOptions___invert__(PyObject *);}
static PyObject *slot_QGL_FormatOptions___invert__(PyObject *sipSelf)
{
     ::QGL::FormatOptions *sipCpp = reinterpret_cast< ::QGL::FormatOptions *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGL_FormatOptions));

    if (!sipCpp)
        return 0;


    {
        {
             ::QGL::FormatOptions*sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = new  ::QGL::FormatOptions(~(*sipCpp));
            Py_END_ALLOW_THREADS

            return sipConvertFromNewType(sipRes,sipType_QGL_FormatOptions,NULL);
        }
    }

    return 0;
}


extern "C" {static PyObject *slot_QGL_FormatOptions___int__(PyObject *);}
static PyObject *slot_QGL_FormatOptions___int__(PyObject *sipSelf)
{
     ::QGL::FormatOptions *sipCpp = reinterpret_cast< ::QGL::FormatOptions *>(sipGetCppPtr((sipSimpleWrapper *)sipSelf,sipType_QGL_FormatOptions));

    if (!sipCpp)
        return 0;


    {
        {
            int sipRes;

            Py_BEGIN_ALLOW_THREADS
            sipRes = *sipCpp;
            Py_END_ALLOW_THREADS

            return SIPLong_FromLong(sipRes);
        }
    }

    return 0;
}


/* Call the instance's destructor. */
extern "C" {static void release_QGL_FormatOptions(void *, int);}
static void release_QGL_FormatOptions(void *sipCppV, int)
{
    Py_BEGIN_ALLOW_THREADS

    delete reinterpret_cast< ::QGL::FormatOptions *>(sipCppV);

    Py_END_ALLOW_THREADS
}


extern "C" {static void assign_QGL_FormatOptions(void *, SIP_SSIZE_T, void *);}
static void assign_QGL_FormatOptions(void *sipDst, SIP_SSIZE_T sipDstIdx, void *sipSrc)
{
    reinterpret_cast< ::QGL::FormatOptions *>(sipDst)[sipDstIdx] = *reinterpret_cast< ::QGL::FormatOptions *>(sipSrc);
}


extern "C" {static void *array_QGL_FormatOptions(SIP_SSIZE_T);}
static void *array_QGL_FormatOptions(SIP_SSIZE_T sipNrElem)
{
    return new  ::QGL::FormatOptions[sipNrElem];
}


extern "C" {static void *copy_QGL_FormatOptions(const void *, SIP_SSIZE_T);}
static void *copy_QGL_FormatOptions(const void *sipSrc, SIP_SSIZE_T sipSrcIdx)
{
    return new  ::QGL::FormatOptions(reinterpret_cast<const  ::QGL::FormatOptions *>(sipSrc)[sipSrcIdx]);
}


extern "C" {static void dealloc_QGL_FormatOptions(sipSimpleWrapper *);}
static void dealloc_QGL_FormatOptions(sipSimpleWrapper *sipSelf)
{
    if (sipIsOwnedByPython(sipSelf))
    {
        release_QGL_FormatOptions(sipGetAddress(sipSelf), 0);
    }
}


extern "C" {static void *init_type_QGL_FormatOptions(sipSimpleWrapper *, PyObject *, PyObject *, PyObject **, PyObject **, PyObject **);}
static void *init_type_QGL_FormatOptions(sipSimpleWrapper *, PyObject *sipArgs, PyObject *sipKwds, PyObject **sipUnused, PyObject **, PyObject **sipParseErr)
{
     ::QGL::FormatOptions *sipCpp = 0;

    {
        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, ""))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new  ::QGL::FormatOptions();
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    {
        int a0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "i", &a0))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new  ::QGL::FormatOptions(a0);
            Py_END_ALLOW_THREADS

            return sipCpp;
        }
    }

    {
        const  ::QGL::FormatOptions* a0;
        int a0State = 0;

        if (sipParseKwdArgs(sipParseErr, sipArgs, sipKwds, NULL, sipUnused, "J1", sipType_QGL_FormatOptions, &a0, &a0State))
        {
            Py_BEGIN_ALLOW_THREADS
            sipCpp = new  ::QGL::FormatOptions(*a0);
            Py_END_ALLOW_THREADS
            sipReleaseType(const_cast< ::QGL::FormatOptions *>(a0),sipType_QGL_FormatOptions,a0State);

            return sipCpp;
        }
    }

    return NULL;
}


extern "C" {static int convertTo_QGL_FormatOptions(PyObject *, void **, int *, PyObject *);}
static int convertTo_QGL_FormatOptions(PyObject *sipPy,void **sipCppPtrV,int *sipIsErr,PyObject *sipTransferObj)
{
     ::QGL::FormatOptions **sipCppPtr = reinterpret_cast< ::QGL::FormatOptions **>(sipCppPtrV);

#line 390 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtCore/qglobal.sip"
// Allow an instance of the base enum whenever a QGL::FormatOptions is expected.

if (sipIsErr == NULL)
    return (PyObject_TypeCheck(sipPy, sipTypeAsPyTypeObject(sipType_QGL_FormatOption)) ||
            sipCanConvertToType(sipPy, sipType_QGL_FormatOptions, SIP_NO_CONVERTORS));

if (PyObject_TypeCheck(sipPy, sipTypeAsPyTypeObject(sipType_QGL_FormatOption)))
{
    *sipCppPtr = new QGL::FormatOptions(int(SIPLong_AsLong(sipPy)));

    return sipGetState(sipTransferObj);
}

*sipCppPtr = reinterpret_cast<QGL::FormatOptions *>(sipConvertToType(sipPy, sipType_QGL_FormatOptions, sipTransferObj, SIP_NO_CONVERTORS, 0, sipIsErr));

return 0;
#line 20265 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"
}


/* Define this type's Python slots. */
static sipPySlotDef slots_QGL_FormatOptions[] = {
    {(void *)slot_QGL_FormatOptions___bool__, bool_slot},
    {(void *)slot_QGL_FormatOptions___ne__, ne_slot},
    {(void *)slot_QGL_FormatOptions___eq__, eq_slot},
    {(void *)slot_QGL_FormatOptions___ixor__, ixor_slot},
    {(void *)slot_QGL_FormatOptions___xor__, xor_slot},
    {(void *)slot_QGL_FormatOptions___ior__, ior_slot},
    {(void *)slot_QGL_FormatOptions___or__, or_slot},
    {(void *)slot_QGL_FormatOptions___iand__, iand_slot},
    {(void *)slot_QGL_FormatOptions___and__, and_slot},
    {(void *)slot_QGL_FormatOptions___invert__, invert_slot},
    {(void *)slot_QGL_FormatOptions___int__, int_slot},
    {0, (sipPySlotType)0}
};

PyDoc_STRVAR(doc_QGL_FormatOptions, "\1QGL.FormatOptions()\n"
"QGL.FormatOptions(Union[QGL.FormatOptions, QGL.FormatOption])\n"
"QGL.FormatOptions(QGL.FormatOptions)");


static pyqt4ClassPluginDef plugin_QGL_FormatOptions = {
    0,
    1,
    0
};


sipClassTypeDef sipTypeDef_QtOpenGL_QGL_FormatOptions = {
    {
        -1,
        0,
        0,
        SIP_TYPE_CLASS,
        sipNameNr_QGL__FormatOptions,
        {0},
        &plugin_QGL_FormatOptions
    },
    {
        sipNameNr_FormatOptions,
        {0, 255, 0},
        0, 0,
        0, 0,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    doc_QGL_FormatOptions,
    sipNameNr_PyQt4_QtCore_pyqtWrapperType,
    sipNameNr_sip_simplewrapper,
    0,
    slots_QGL_FormatOptions,
    init_type_QGL_FormatOptions,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    dealloc_QGL_FormatOptions,
    assign_QGL_FormatOptions,
    array_QGL_FormatOptions,
    copy_QGL_FormatOptions,
    release_QGL_FormatOptions,
    0,
    convertTo_QGL_FormatOptions,
    0,
    0,
    0,
    0,
    0
};

#line 26 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtOpenGL/qgl.sip"
#include <qgl.h>
#line 20351 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"

#line 52 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/src/PyQt4_gpl_x11-4.12.3/sip/QtGui/qpaintengine.sip"
#include <qpaintengine.h>
#line 20355 "/wip/cygport-git/python-pyqt4/python-pyqt4-4.12.3-1.x86_64/build/QtOpenGL/sipQtOpenGLpart0.cpp"


PyDoc_STRVAR(doc_QGL_setPreferredPaintEngine, "setPreferredPaintEngine(QPaintEngine.Type)");

extern "C" {static PyObject *meth_QGL_setPreferredPaintEngine(PyObject *, PyObject *);}
static PyObject *meth_QGL_setPreferredPaintEngine(PyObject *, PyObject *sipArgs)
{
    PyObject *sipParseErr = NULL;

    {
         ::QPaintEngine::Type a0;

        if (sipParseArgs(&sipParseErr, sipArgs, "E", sipType_QPaintEngine_Type, &a0))
        {
            Py_BEGIN_ALLOW_THREADS
             ::QGL::setPreferredPaintEngine(a0);
            Py_END_ALLOW_THREADS

            Py_INCREF(Py_None);
            return Py_None;
        }
    }

    /* Raise an exception if the arguments couldn't be parsed. */
    sipNoFunction(sipParseErr, sipName_setPreferredPaintEngine, doc_QGL_setPreferredPaintEngine);

    return NULL;
}


static PyMethodDef methods_QGL[] = {
    {SIP_MLNAME_CAST(sipName_setPreferredPaintEngine), meth_QGL_setPreferredPaintEngine, METH_VARARGS, SIP_MLDOC_CAST(doc_QGL_setPreferredPaintEngine)}
};

static sipEnumMemberDef enummembers_QGL[] = {
    {sipName_AccumBuffer, static_cast<int>( ::QGL::AccumBuffer), 1},
    {sipName_AlphaChannel, static_cast<int>( ::QGL::AlphaChannel), 1},
    {sipName_ColorIndex, static_cast<int>( ::QGL::ColorIndex), 1},
    {sipName_DeprecatedFunctions, static_cast<int>( ::QGL::DeprecatedFunctions), 1},
    {sipName_DepthBuffer, static_cast<int>( ::QGL::DepthBuffer), 1},
    {sipName_DirectRendering, static_cast<int>( ::QGL::DirectRendering), 1},
    {sipName_DoubleBuffer, static_cast<int>( ::QGL::DoubleBuffer), 1},
    {sipName_HasOverlay, static_cast<int>( ::QGL::HasOverlay), 1},
    {sipName_IndirectRendering, static_cast<int>( ::QGL::IndirectRendering), 1},
    {sipName_NoAccumBuffer, static_cast<int>( ::QGL::NoAccumBuffer), 1},
    {sipName_NoAlphaChannel, static_cast<int>( ::QGL::NoAlphaChannel), 1},
    {sipName_NoDeprecatedFunctions, static_cast<int>( ::QGL::NoDeprecatedFunctions), 1},
    {sipName_NoDepthBuffer, static_cast<int>( ::QGL::NoDepthBuffer), 1},
    {sipName_NoOverlay, static_cast<int>( ::QGL::NoOverlay), 1},
    {sipName_NoSampleBuffers, static_cast<int>( ::QGL::NoSampleBuffers), 1},
    {sipName_NoStencilBuffer, static_cast<int>( ::QGL::NoStencilBuffer), 1},
    {sipName_NoStereoBuffers, static_cast<int>( ::QGL::NoStereoBuffers), 1},
    {sipName_Rgba, static_cast<int>( ::QGL::Rgba), 1},
    {sipName_SampleBuffers, static_cast<int>( ::QGL::SampleBuffers), 1},
    {sipName_SingleBuffer, static_cast<int>( ::QGL::SingleBuffer), 1},
    {sipName_StencilBuffer, static_cast<int>( ::QGL::StencilBuffer), 1},
    {sipName_StereoBuffers, static_cast<int>( ::QGL::StereoBuffers), 1},
};


static pyqt4ClassPluginDef plugin_QGL = {
    0,
    0,
    0
};


sipClassTypeDef sipTypeDef_QtOpenGL_QGL = {
    {
        -1,
        0,
        0,
        SIP_TYPE_NAMESPACE,
        sipNameNr_QGL,
        {0},
        &plugin_QGL
    },
    {
        sipNameNr_QGL,
        {0, 0, 1},
        1, methods_QGL,
        22, enummembers_QGL,
        0, 0,
        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
    0,
    -1,
    -1,
    0,
    0,
    0,
    0,
    0,
#if PY_MAJOR_VERSION >= 3
    0,
    0,
#else
    0,
    0,
    0,
    0,
#endif
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0
};
