com_trolltech_qt_opengl0.cpp
2931 lines
| 103.5 KiB
| text/x-c
|
CppLexer
Orochimarufan
|
r205 | #include "com_trolltech_qt_opengl0.h" | ||
#include <PythonQtConversion.h> | ||||
#include <PythonQtMethodInfo.h> | ||||
#include <PythonQtSignalReceiver.h> | ||||
#include <QIconEngine> | ||||
#include <QImage> | ||||
#include <QPixmap> | ||||
#include <QVariant> | ||||
#include <qaction.h> | ||||
#include <qbitmap.h> | ||||
#include <qbytearray.h> | ||||
#include <qcolor.h> | ||||
#include <qcoreevent.h> | ||||
#include <qcursor.h> | ||||
#include <qevent.h> | ||||
#include <qfont.h> | ||||
#include <qgenericmatrix.h> | ||||
#include <qgl.h> | ||||
#include <qglbuffer.h> | ||||
#include <qglcolormap.h> | ||||
#include <qglframebufferobject.h> | ||||
#include <qglfunctions.h> | ||||
#include <qglpixelbuffer.h> | ||||
#include <qglshaderprogram.h> | ||||
#include <qgraphicseffect.h> | ||||
#include <qgraphicsproxywidget.h> | ||||
#include <qimage.h> | ||||
#include <qkeysequence.h> | ||||
#include <qlayout.h> | ||||
#include <qlist.h> | ||||
#include <qlocale.h> | ||||
#include <qmargins.h> | ||||
#include <qmatrix4x4.h> | ||||
#include <qobject.h> | ||||
#include <qpaintdevice.h> | ||||
#include <qpaintengine.h> | ||||
#include <qpainter.h> | ||||
#include <qpalette.h> | ||||
#include <qpixmap.h> | ||||
#include <qpoint.h> | ||||
#include <qrect.h> | ||||
#include <qregion.h> | ||||
#include <qsize.h> | ||||
#include <qsizepolicy.h> | ||||
#include <qstyle.h> | ||||
#include <qtransform.h> | ||||
#include <qvector2d.h> | ||||
#include <qvector3d.h> | ||||
#include <qvector4d.h> | ||||
#include <qwidget.h> | ||||
QGLBuffer* PythonQtWrapper_QGLBuffer::new_QGLBuffer() | ||||
{ | ||||
return new QGLBuffer(); } | ||||
QGLBuffer* PythonQtWrapper_QGLBuffer::new_QGLBuffer(QGLBuffer::Type type) | ||||
{ | ||||
return new QGLBuffer(type); } | ||||
QGLBuffer* PythonQtWrapper_QGLBuffer::new_QGLBuffer(const QGLBuffer& other) | ||||
{ | ||||
return new QGLBuffer(other); } | ||||
void PythonQtWrapper_QGLBuffer::allocate(QGLBuffer* theWrappedObject, const void* data, int count) | ||||
{ | ||||
( theWrappedObject->allocate(data, count)); | ||||
} | ||||
void PythonQtWrapper_QGLBuffer::allocate(QGLBuffer* theWrappedObject, int count) | ||||
{ | ||||
( theWrappedObject->allocate(count)); | ||||
} | ||||
bool PythonQtWrapper_QGLBuffer::bind(QGLBuffer* theWrappedObject) | ||||
{ | ||||
return ( theWrappedObject->bind()); | ||||
} | ||||
bool PythonQtWrapper_QGLBuffer::create(QGLBuffer* theWrappedObject) | ||||
{ | ||||
return ( theWrappedObject->create()); | ||||
} | ||||
void PythonQtWrapper_QGLBuffer::destroy(QGLBuffer* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->destroy()); | ||||
} | ||||
bool PythonQtWrapper_QGLBuffer::isCreated(QGLBuffer* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isCreated()); | ||||
} | ||||
void* PythonQtWrapper_QGLBuffer::map(QGLBuffer* theWrappedObject, QGLBuffer::Access access) | ||||
{ | ||||
return ( theWrappedObject->map(access)); | ||||
} | ||||
QGLBuffer* PythonQtWrapper_QGLBuffer::operator_assign(QGLBuffer* theWrappedObject, const QGLBuffer& other) | ||||
{ | ||||
return &( (*theWrappedObject)= other); | ||||
} | ||||
bool PythonQtWrapper_QGLBuffer::read(QGLBuffer* theWrappedObject, int offset, void* data, int count) | ||||
{ | ||||
return ( theWrappedObject->read(offset, data, count)); | ||||
} | ||||
void PythonQtWrapper_QGLBuffer::release(QGLBuffer* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->release()); | ||||
} | ||||
void PythonQtWrapper_QGLBuffer::static_QGLBuffer_release(QGLBuffer::Type type) | ||||
{ | ||||
(QGLBuffer::release(type)); | ||||
} | ||||
void PythonQtWrapper_QGLBuffer::setUsagePattern(QGLBuffer* theWrappedObject, QGLBuffer::UsagePattern value) | ||||
{ | ||||
( theWrappedObject->setUsagePattern(value)); | ||||
} | ||||
int PythonQtWrapper_QGLBuffer::size(QGLBuffer* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->size()); | ||||
} | ||||
QGLBuffer::Type PythonQtWrapper_QGLBuffer::type(QGLBuffer* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->type()); | ||||
} | ||||
bool PythonQtWrapper_QGLBuffer::unmap(QGLBuffer* theWrappedObject) | ||||
{ | ||||
return ( theWrappedObject->unmap()); | ||||
} | ||||
QGLBuffer::UsagePattern PythonQtWrapper_QGLBuffer::usagePattern(QGLBuffer* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->usagePattern()); | ||||
} | ||||
void PythonQtWrapper_QGLBuffer::write(QGLBuffer* theWrappedObject, int offset, const void* data, int count) | ||||
{ | ||||
( theWrappedObject->write(offset, data, count)); | ||||
} | ||||
PythonQtShell_QGLColormap::~PythonQtShell_QGLColormap() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
QGLColormap* PythonQtWrapper_QGLColormap::new_QGLColormap() | ||||
{ | ||||
return new PythonQtShell_QGLColormap(); } | ||||
QGLColormap* PythonQtWrapper_QGLColormap::new_QGLColormap(const QGLColormap& arg__1) | ||||
{ | ||||
return new PythonQtShell_QGLColormap(arg__1); } | ||||
QColor PythonQtWrapper_QGLColormap::entryColor(QGLColormap* theWrappedObject, int idx) const | ||||
{ | ||||
return ( theWrappedObject->entryColor(idx)); | ||||
} | ||||
unsigned int PythonQtWrapper_QGLColormap::entryRgb(QGLColormap* theWrappedObject, int idx) const | ||||
{ | ||||
return ( theWrappedObject->entryRgb(idx)); | ||||
} | ||||
int PythonQtWrapper_QGLColormap::find(QGLColormap* theWrappedObject, unsigned int color) const | ||||
{ | ||||
return ( theWrappedObject->find(color)); | ||||
} | ||||
int PythonQtWrapper_QGLColormap::findNearest(QGLColormap* theWrappedObject, unsigned int color) const | ||||
{ | ||||
return ( theWrappedObject->findNearest(color)); | ||||
} | ||||
bool PythonQtWrapper_QGLColormap::isEmpty(QGLColormap* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isEmpty()); | ||||
} | ||||
void PythonQtWrapper_QGLColormap::setEntries(QGLColormap* theWrappedObject, int count, const unsigned int* colors, int base) | ||||
{ | ||||
( theWrappedObject->setEntries(count, colors, base)); | ||||
} | ||||
void PythonQtWrapper_QGLColormap::setEntry(QGLColormap* theWrappedObject, int idx, const QColor& color) | ||||
{ | ||||
( theWrappedObject->setEntry(idx, color)); | ||||
} | ||||
void PythonQtWrapper_QGLColormap::setEntry(QGLColormap* theWrappedObject, int idx, unsigned int color) | ||||
{ | ||||
( theWrappedObject->setEntry(idx, color)); | ||||
} | ||||
int PythonQtWrapper_QGLColormap::size(QGLColormap* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->size()); | ||||
} | ||||
PythonQtShell_QGLContext::~PythonQtShell_QGLContext() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
bool PythonQtShell_QGLContext::chooseContext(const QGLContext* shareContext) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "chooseContext"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "const QGLContext*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&shareContext}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("chooseContext", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QGLContext::chooseContext(shareContext); | ||||
} | ||||
bool PythonQtShell_QGLContext::create(const QGLContext* shareContext) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "create"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "const QGLContext*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&shareContext}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("create", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QGLContext::create(shareContext); | ||||
} | ||||
void PythonQtShell_QGLContext::doneCurrent() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "doneCurrent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={""}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLContext::doneCurrent(); | ||||
} | ||||
void PythonQtShell_QGLContext::makeCurrent() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "makeCurrent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={""}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLContext::makeCurrent(); | ||||
} | ||||
void PythonQtShell_QGLContext::swapBuffers() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "swapBuffers"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={""}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLContext::swapBuffers(); | ||||
} | ||||
QGLContext* PythonQtWrapper_QGLContext::new_QGLContext(const QGLFormat& format) | ||||
{ | ||||
return new PythonQtShell_QGLContext(format); } | ||||
QGLContext* PythonQtWrapper_QGLContext::new_QGLContext(const QGLFormat& format, QPaintDevice* device) | ||||
{ | ||||
return new PythonQtShell_QGLContext(format, device); } | ||||
bool PythonQtWrapper_QGLContext::static_QGLContext_areSharing(const QGLContext* context1, const QGLContext* context2) | ||||
{ | ||||
return (QGLContext::areSharing(context1, context2)); | ||||
} | ||||
bool PythonQtWrapper_QGLContext::chooseContext(QGLContext* theWrappedObject, const QGLContext* shareContext) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QGLContext*)theWrappedObject)->promoted_chooseContext(shareContext)); | ||||
} | ||||
bool PythonQtWrapper_QGLContext::create(QGLContext* theWrappedObject, const QGLContext* shareContext) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QGLContext*)theWrappedObject)->promoted_create(shareContext)); | ||||
} | ||||
const QGLContext* PythonQtWrapper_QGLContext::static_QGLContext_currentContext() | ||||
{ | ||||
return (QGLContext::currentContext()); | ||||
} | ||||
QPaintDevice* PythonQtWrapper_QGLContext::device(QGLContext* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->device()); | ||||
} | ||||
void PythonQtWrapper_QGLContext::doneCurrent(QGLContext* theWrappedObject) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QGLContext*)theWrappedObject)->promoted_doneCurrent()); | ||||
} | ||||
QGLFormat PythonQtWrapper_QGLContext::format(QGLContext* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->format()); | ||||
} | ||||
QGLFunctions* PythonQtWrapper_QGLContext::functions(QGLContext* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->functions()); | ||||
} | ||||
bool PythonQtWrapper_QGLContext::isSharing(QGLContext* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isSharing()); | ||||
} | ||||
bool PythonQtWrapper_QGLContext::isValid(QGLContext* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isValid()); | ||||
} | ||||
void PythonQtWrapper_QGLContext::makeCurrent(QGLContext* theWrappedObject) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QGLContext*)theWrappedObject)->promoted_makeCurrent()); | ||||
} | ||||
void PythonQtWrapper_QGLContext::moveToThread(QGLContext* theWrappedObject, QThread* thread) | ||||
{ | ||||
( theWrappedObject->moveToThread(thread)); | ||||
} | ||||
QColor PythonQtWrapper_QGLContext::overlayTransparentColor(QGLContext* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->overlayTransparentColor()); | ||||
} | ||||
QGLFormat PythonQtWrapper_QGLContext::requestedFormat(QGLContext* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->requestedFormat()); | ||||
} | ||||
void PythonQtWrapper_QGLContext::reset(QGLContext* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->reset()); | ||||
} | ||||
void PythonQtWrapper_QGLContext::setFormat(QGLContext* theWrappedObject, const QGLFormat& format) | ||||
{ | ||||
( theWrappedObject->setFormat(format)); | ||||
} | ||||
void PythonQtWrapper_QGLContext::static_QGLContext_setTextureCacheLimit(int size) | ||||
{ | ||||
(QGLContext::setTextureCacheLimit(size)); | ||||
} | ||||
void PythonQtWrapper_QGLContext::swapBuffers(QGLContext* theWrappedObject) const | ||||
{ | ||||
( ((PythonQtPublicPromoter_QGLContext*)theWrappedObject)->promoted_swapBuffers()); | ||||
} | ||||
int PythonQtWrapper_QGLContext::static_QGLContext_textureCacheLimit() | ||||
{ | ||||
return (QGLContext::textureCacheLimit()); | ||||
} | ||||
PythonQtShell_QGLFramebufferObject::~PythonQtShell_QGLFramebufferObject() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
int PythonQtShell_QGLFramebufferObject::devType() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
int returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result); | ||||
} else { | ||||
returnValue = *((int*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QGLFramebufferObject::devType(); | ||||
} | ||||
void PythonQtShell_QGLFramebufferObject::initPainter(QPainter* painter) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&painter}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLFramebufferObject::initPainter(painter); | ||||
} | ||||
int PythonQtShell_QGLFramebufferObject::metric(QPaintDevice::PaintDeviceMetric metric) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
int returnValue; | ||||
void* args[2] = {NULL, (void*)&metric}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result); | ||||
} else { | ||||
returnValue = *((int*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QGLFramebufferObject::metric(metric); | ||||
} | ||||
QPaintEngine* PythonQtShell_QGLFramebufferObject::paintEngine() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QPaintEngine*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QPaintEngine* returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QPaintEngine**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QGLFramebufferObject::paintEngine(); | ||||
} | ||||
QPaintDevice* PythonQtShell_QGLFramebufferObject::redirected(QPoint* offset) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QPaintDevice* returnValue; | ||||
void* args[2] = {NULL, (void*)&offset}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QPaintDevice**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QGLFramebufferObject::redirected(offset); | ||||
} | ||||
QPainter* PythonQtShell_QGLFramebufferObject::sharedPainter() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QPainter* returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QPainter**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QGLFramebufferObject::sharedPainter(); | ||||
} | ||||
QGLFramebufferObject* PythonQtWrapper_QGLFramebufferObject::new_QGLFramebufferObject(const QSize& size, const QGLFramebufferObjectFormat& format) | ||||
{ | ||||
return new PythonQtShell_QGLFramebufferObject(size, format); } | ||||
QGLFramebufferObject* PythonQtWrapper_QGLFramebufferObject::new_QGLFramebufferObject(int width, int height, const QGLFramebufferObjectFormat& format) | ||||
{ | ||||
return new PythonQtShell_QGLFramebufferObject(width, height, format); } | ||||
QGLFramebufferObject::Attachment PythonQtWrapper_QGLFramebufferObject::attachment(QGLFramebufferObject* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->attachment()); | ||||
} | ||||
bool PythonQtWrapper_QGLFramebufferObject::bind(QGLFramebufferObject* theWrappedObject) | ||||
{ | ||||
return ( theWrappedObject->bind()); | ||||
} | ||||
bool PythonQtWrapper_QGLFramebufferObject::static_QGLFramebufferObject_bindDefault() | ||||
{ | ||||
return (QGLFramebufferObject::bindDefault()); | ||||
} | ||||
int PythonQtWrapper_QGLFramebufferObject::devType(QGLFramebufferObject* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QGLFramebufferObject*)theWrappedObject)->promoted_devType()); | ||||
} | ||||
QGLFramebufferObjectFormat PythonQtWrapper_QGLFramebufferObject::format(QGLFramebufferObject* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->format()); | ||||
} | ||||
bool PythonQtWrapper_QGLFramebufferObject::static_QGLFramebufferObject_hasOpenGLFramebufferBlit() | ||||
{ | ||||
return (QGLFramebufferObject::hasOpenGLFramebufferBlit()); | ||||
} | ||||
bool PythonQtWrapper_QGLFramebufferObject::static_QGLFramebufferObject_hasOpenGLFramebufferObjects() | ||||
{ | ||||
return (QGLFramebufferObject::hasOpenGLFramebufferObjects()); | ||||
} | ||||
bool PythonQtWrapper_QGLFramebufferObject::isBound(QGLFramebufferObject* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isBound()); | ||||
} | ||||
bool PythonQtWrapper_QGLFramebufferObject::isValid(QGLFramebufferObject* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isValid()); | ||||
} | ||||
int PythonQtWrapper_QGLFramebufferObject::metric(QGLFramebufferObject* theWrappedObject, QPaintDevice::PaintDeviceMetric metric) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QGLFramebufferObject*)theWrappedObject)->promoted_metric(metric)); | ||||
} | ||||
QPaintEngine* PythonQtWrapper_QGLFramebufferObject::paintEngine(QGLFramebufferObject* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QGLFramebufferObject*)theWrappedObject)->promoted_paintEngine()); | ||||
} | ||||
bool PythonQtWrapper_QGLFramebufferObject::release(QGLFramebufferObject* theWrappedObject) | ||||
{ | ||||
return ( theWrappedObject->release()); | ||||
} | ||||
QSize PythonQtWrapper_QGLFramebufferObject::size(QGLFramebufferObject* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->size()); | ||||
} | ||||
QImage PythonQtWrapper_QGLFramebufferObject::toImage(QGLFramebufferObject* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->toImage()); | ||||
} | ||||
QGLFramebufferObjectFormat* PythonQtWrapper_QGLFramebufferObjectFormat::new_QGLFramebufferObjectFormat() | ||||
{ | ||||
return new QGLFramebufferObjectFormat(); } | ||||
QGLFramebufferObjectFormat* PythonQtWrapper_QGLFramebufferObjectFormat::new_QGLFramebufferObjectFormat(const QGLFramebufferObjectFormat& other) | ||||
{ | ||||
return new QGLFramebufferObjectFormat(other); } | ||||
QGLFramebufferObject::Attachment PythonQtWrapper_QGLFramebufferObjectFormat::attachment(QGLFramebufferObjectFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->attachment()); | ||||
} | ||||
bool PythonQtWrapper_QGLFramebufferObjectFormat::mipmap(QGLFramebufferObjectFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->mipmap()); | ||||
} | ||||
bool PythonQtWrapper_QGLFramebufferObjectFormat::__ne__(QGLFramebufferObjectFormat* theWrappedObject, const QGLFramebufferObjectFormat& other) const | ||||
{ | ||||
return ( (*theWrappedObject)!= other); | ||||
} | ||||
QGLFramebufferObjectFormat* PythonQtWrapper_QGLFramebufferObjectFormat::operator_assign(QGLFramebufferObjectFormat* theWrappedObject, const QGLFramebufferObjectFormat& other) | ||||
{ | ||||
return &( (*theWrappedObject)= other); | ||||
} | ||||
bool PythonQtWrapper_QGLFramebufferObjectFormat::__eq__(QGLFramebufferObjectFormat* theWrappedObject, const QGLFramebufferObjectFormat& other) const | ||||
{ | ||||
return ( (*theWrappedObject)== other); | ||||
} | ||||
int PythonQtWrapper_QGLFramebufferObjectFormat::samples(QGLFramebufferObjectFormat* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->samples()); | ||||
} | ||||
void PythonQtWrapper_QGLFramebufferObjectFormat::setAttachment(QGLFramebufferObjectFormat* theWrappedObject, QGLFramebufferObject::Attachment attachment) | ||||
{ | ||||
( theWrappedObject->setAttachment(attachment)); | ||||
} | ||||
void PythonQtWrapper_QGLFramebufferObjectFormat::setMipmap(QGLFramebufferObjectFormat* theWrappedObject, bool enabled) | ||||
{ | ||||
( theWrappedObject->setMipmap(enabled)); | ||||
} | ||||
void PythonQtWrapper_QGLFramebufferObjectFormat::setSamples(QGLFramebufferObjectFormat* theWrappedObject, int samples) | ||||
{ | ||||
( theWrappedObject->setSamples(samples)); | ||||
} | ||||
QGLFunctions* PythonQtWrapper_QGLFunctions::new_QGLFunctions() | ||||
{ | ||||
return new QGLFunctions(); } | ||||
QGLFunctions* PythonQtWrapper_QGLFunctions::new_QGLFunctions(const QGLContext* context) | ||||
{ | ||||
return new QGLFunctions(context); } | ||||
void PythonQtWrapper_QGLFunctions::glReleaseShaderCompiler(QGLFunctions* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->glReleaseShaderCompiler()); | ||||
} | ||||
bool PythonQtWrapper_QGLFunctions::hasOpenGLFeature(QGLFunctions* theWrappedObject, QGLFunctions::OpenGLFeature feature) const | ||||
{ | ||||
return ( theWrappedObject->hasOpenGLFeature(feature)); | ||||
} | ||||
void PythonQtWrapper_QGLFunctions::initializeGLFunctions(QGLFunctions* theWrappedObject, const QGLContext* context) | ||||
{ | ||||
( theWrappedObject->initializeGLFunctions(context)); | ||||
} | ||||
PythonQtShell_QGLPixelBuffer::~PythonQtShell_QGLPixelBuffer() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
int PythonQtShell_QGLPixelBuffer::devType() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
int returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result); | ||||
} else { | ||||
returnValue = *((int*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QGLPixelBuffer::devType(); | ||||
} | ||||
void PythonQtShell_QGLPixelBuffer::initPainter(QPainter* painter) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&painter}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLPixelBuffer::initPainter(painter); | ||||
} | ||||
int PythonQtShell_QGLPixelBuffer::metric(QPaintDevice::PaintDeviceMetric metric) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
int returnValue; | ||||
void* args[2] = {NULL, (void*)&metric}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result); | ||||
} else { | ||||
returnValue = *((int*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QGLPixelBuffer::metric(metric); | ||||
} | ||||
QPaintEngine* PythonQtShell_QGLPixelBuffer::paintEngine() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QPaintEngine*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QPaintEngine* returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QPaintEngine**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QGLPixelBuffer::paintEngine(); | ||||
} | ||||
QPaintDevice* PythonQtShell_QGLPixelBuffer::redirected(QPoint* offset) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QPaintDevice* returnValue; | ||||
void* args[2] = {NULL, (void*)&offset}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QPaintDevice**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QGLPixelBuffer::redirected(offset); | ||||
} | ||||
QPainter* PythonQtShell_QGLPixelBuffer::sharedPainter() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QPainter* returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QPainter**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QGLPixelBuffer::sharedPainter(); | ||||
} | ||||
QGLPixelBuffer* PythonQtWrapper_QGLPixelBuffer::new_QGLPixelBuffer(const QSize& size, const QGLFormat& format, QGLWidget* shareWidget) | ||||
{ | ||||
return new PythonQtShell_QGLPixelBuffer(size, format, shareWidget); } | ||||
QGLPixelBuffer* PythonQtWrapper_QGLPixelBuffer::new_QGLPixelBuffer(int width, int height, const QGLFormat& format, QGLWidget* shareWidget) | ||||
{ | ||||
return new PythonQtShell_QGLPixelBuffer(width, height, format, shareWidget); } | ||||
QGLContext* PythonQtWrapper_QGLPixelBuffer::context(QGLPixelBuffer* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->context()); | ||||
} | ||||
int PythonQtWrapper_QGLPixelBuffer::devType(QGLPixelBuffer* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QGLPixelBuffer*)theWrappedObject)->promoted_devType()); | ||||
} | ||||
bool PythonQtWrapper_QGLPixelBuffer::doneCurrent(QGLPixelBuffer* theWrappedObject) | ||||
{ | ||||
return ( theWrappedObject->doneCurrent()); | ||||
} | ||||
QGLFormat PythonQtWrapper_QGLPixelBuffer::format(QGLPixelBuffer* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->format()); | ||||
} | ||||
Qt::HANDLE PythonQtWrapper_QGLPixelBuffer::handle(QGLPixelBuffer* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->handle()); | ||||
} | ||||
bool PythonQtWrapper_QGLPixelBuffer::static_QGLPixelBuffer_hasOpenGLPbuffers() | ||||
{ | ||||
return (QGLPixelBuffer::hasOpenGLPbuffers()); | ||||
} | ||||
bool PythonQtWrapper_QGLPixelBuffer::isValid(QGLPixelBuffer* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isValid()); | ||||
} | ||||
bool PythonQtWrapper_QGLPixelBuffer::makeCurrent(QGLPixelBuffer* theWrappedObject) | ||||
{ | ||||
return ( theWrappedObject->makeCurrent()); | ||||
} | ||||
int PythonQtWrapper_QGLPixelBuffer::metric(QGLPixelBuffer* theWrappedObject, QPaintDevice::PaintDeviceMetric metric) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QGLPixelBuffer*)theWrappedObject)->promoted_metric(metric)); | ||||
} | ||||
QPaintEngine* PythonQtWrapper_QGLPixelBuffer::paintEngine(QGLPixelBuffer* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QGLPixelBuffer*)theWrappedObject)->promoted_paintEngine()); | ||||
} | ||||
void PythonQtWrapper_QGLPixelBuffer::releaseFromDynamicTexture(QGLPixelBuffer* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->releaseFromDynamicTexture()); | ||||
} | ||||
QSize PythonQtWrapper_QGLPixelBuffer::size(QGLPixelBuffer* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->size()); | ||||
} | ||||
QImage PythonQtWrapper_QGLPixelBuffer::toImage(QGLPixelBuffer* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->toImage()); | ||||
} | ||||
PythonQtShell_QGLShader::~PythonQtShell_QGLShader() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_QGLShader::childEvent(QChildEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QChildEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLShader::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QGLShader::customEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLShader::customEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QGLShader::event(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "QEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QGLShader::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QGLShader::eventFilter(QObject* arg__1, QEvent* arg__2) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
bool returnValue; | ||||
void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QGLShader::eventFilter(arg__1, arg__2); | ||||
} | ||||
void PythonQtShell_QGLShader::timerEvent(QTimerEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QTimerEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLShader::timerEvent(arg__1); | ||||
} | ||||
QGLShader* PythonQtWrapper_QGLShader::new_QGLShader(QGLShader::ShaderType type, QObject* parent) | ||||
{ | ||||
return new PythonQtShell_QGLShader(type, parent); } | ||||
QGLShader* PythonQtWrapper_QGLShader::new_QGLShader(QGLShader::ShaderType type, const QGLContext* context, QObject* parent) | ||||
{ | ||||
return new PythonQtShell_QGLShader(type, context, parent); } | ||||
bool PythonQtWrapper_QGLShader::compileSourceCode(QGLShader* theWrappedObject, const QByteArray& source) | ||||
{ | ||||
return ( theWrappedObject->compileSourceCode(source)); | ||||
} | ||||
bool PythonQtWrapper_QGLShader::compileSourceCode(QGLShader* theWrappedObject, const QString& source) | ||||
{ | ||||
return ( theWrappedObject->compileSourceCode(source)); | ||||
} | ||||
bool PythonQtWrapper_QGLShader::compileSourceCode(QGLShader* theWrappedObject, const char* source) | ||||
{ | ||||
return ( theWrappedObject->compileSourceCode(source)); | ||||
} | ||||
bool PythonQtWrapper_QGLShader::compileSourceFile(QGLShader* theWrappedObject, const QString& fileName) | ||||
{ | ||||
return ( theWrappedObject->compileSourceFile(fileName)); | ||||
} | ||||
bool PythonQtWrapper_QGLShader::static_QGLShader_hasOpenGLShaders(QGLShader::ShaderType type, const QGLContext* context) | ||||
{ | ||||
return (QGLShader::hasOpenGLShaders(type, context)); | ||||
} | ||||
bool PythonQtWrapper_QGLShader::isCompiled(QGLShader* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isCompiled()); | ||||
} | ||||
QString PythonQtWrapper_QGLShader::log(QGLShader* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->log()); | ||||
} | ||||
QGLShader::ShaderType PythonQtWrapper_QGLShader::shaderType(QGLShader* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->shaderType()); | ||||
} | ||||
QByteArray PythonQtWrapper_QGLShader::sourceCode(QGLShader* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->sourceCode()); | ||||
} | ||||
PythonQtShell_QGLShaderProgram::~PythonQtShell_QGLShaderProgram() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_QGLShaderProgram::childEvent(QChildEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QChildEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLShaderProgram::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QGLShaderProgram::customEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLShaderProgram::customEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QGLShaderProgram::event(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "QEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QGLShaderProgram::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QGLShaderProgram::eventFilter(QObject* arg__1, QEvent* arg__2) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
bool returnValue; | ||||
void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QGLShaderProgram::eventFilter(arg__1, arg__2); | ||||
} | ||||
bool PythonQtShell_QGLShaderProgram::link() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "link"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
bool returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("link", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QGLShaderProgram::link(); | ||||
} | ||||
void PythonQtShell_QGLShaderProgram::timerEvent(QTimerEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QTimerEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLShaderProgram::timerEvent(arg__1); | ||||
} | ||||
QGLShaderProgram* PythonQtWrapper_QGLShaderProgram::new_QGLShaderProgram(QObject* parent) | ||||
{ | ||||
return new PythonQtShell_QGLShaderProgram(parent); } | ||||
QGLShaderProgram* PythonQtWrapper_QGLShaderProgram::new_QGLShaderProgram(const QGLContext* context, QObject* parent) | ||||
{ | ||||
return new PythonQtShell_QGLShaderProgram(context, parent); } | ||||
bool PythonQtWrapper_QGLShaderProgram::addShader(QGLShaderProgram* theWrappedObject, QGLShader* shader) | ||||
{ | ||||
return ( theWrappedObject->addShader(shader)); | ||||
} | ||||
bool PythonQtWrapper_QGLShaderProgram::addShaderFromSourceCode(QGLShaderProgram* theWrappedObject, QGLShader::ShaderType type, const QByteArray& source) | ||||
{ | ||||
return ( theWrappedObject->addShaderFromSourceCode(type, source)); | ||||
} | ||||
bool PythonQtWrapper_QGLShaderProgram::addShaderFromSourceCode(QGLShaderProgram* theWrappedObject, QGLShader::ShaderType type, const QString& source) | ||||
{ | ||||
return ( theWrappedObject->addShaderFromSourceCode(type, source)); | ||||
} | ||||
bool PythonQtWrapper_QGLShaderProgram::addShaderFromSourceCode(QGLShaderProgram* theWrappedObject, QGLShader::ShaderType type, const char* source) | ||||
{ | ||||
return ( theWrappedObject->addShaderFromSourceCode(type, source)); | ||||
} | ||||
bool PythonQtWrapper_QGLShaderProgram::addShaderFromSourceFile(QGLShaderProgram* theWrappedObject, QGLShader::ShaderType type, const QString& fileName) | ||||
{ | ||||
return ( theWrappedObject->addShaderFromSourceFile(type, fileName)); | ||||
} | ||||
int PythonQtWrapper_QGLShaderProgram::attributeLocation(QGLShaderProgram* theWrappedObject, const QByteArray& name) const | ||||
{ | ||||
return ( theWrappedObject->attributeLocation(name)); | ||||
} | ||||
int PythonQtWrapper_QGLShaderProgram::attributeLocation(QGLShaderProgram* theWrappedObject, const QString& name) const | ||||
{ | ||||
return ( theWrappedObject->attributeLocation(name)); | ||||
} | ||||
int PythonQtWrapper_QGLShaderProgram::attributeLocation(QGLShaderProgram* theWrappedObject, const char* name) const | ||||
{ | ||||
return ( theWrappedObject->attributeLocation(name)); | ||||
} | ||||
bool PythonQtWrapper_QGLShaderProgram::bind(QGLShaderProgram* theWrappedObject) | ||||
{ | ||||
return ( theWrappedObject->bind()); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::bindAttributeLocation(QGLShaderProgram* theWrappedObject, const QByteArray& name, int location) | ||||
{ | ||||
( theWrappedObject->bindAttributeLocation(name, location)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::bindAttributeLocation(QGLShaderProgram* theWrappedObject, const QString& name, int location) | ||||
{ | ||||
( theWrappedObject->bindAttributeLocation(name, location)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::bindAttributeLocation(QGLShaderProgram* theWrappedObject, const char* name, int location) | ||||
{ | ||||
( theWrappedObject->bindAttributeLocation(name, location)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::disableAttributeArray(QGLShaderProgram* theWrappedObject, const char* name) | ||||
{ | ||||
( theWrappedObject->disableAttributeArray(name)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::disableAttributeArray(QGLShaderProgram* theWrappedObject, int location) | ||||
{ | ||||
( theWrappedObject->disableAttributeArray(location)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::enableAttributeArray(QGLShaderProgram* theWrappedObject, const char* name) | ||||
{ | ||||
( theWrappedObject->enableAttributeArray(name)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::enableAttributeArray(QGLShaderProgram* theWrappedObject, int location) | ||||
{ | ||||
( theWrappedObject->enableAttributeArray(location)); | ||||
} | ||||
int PythonQtWrapper_QGLShaderProgram::geometryOutputVertexCount(QGLShaderProgram* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->geometryOutputVertexCount()); | ||||
} | ||||
bool PythonQtWrapper_QGLShaderProgram::static_QGLShaderProgram_hasOpenGLShaderPrograms(const QGLContext* context) | ||||
{ | ||||
return (QGLShaderProgram::hasOpenGLShaderPrograms(context)); | ||||
} | ||||
bool PythonQtWrapper_QGLShaderProgram::isLinked(QGLShaderProgram* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isLinked()); | ||||
} | ||||
bool PythonQtWrapper_QGLShaderProgram::link(QGLShaderProgram* theWrappedObject) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QGLShaderProgram*)theWrappedObject)->promoted_link()); | ||||
} | ||||
QString PythonQtWrapper_QGLShaderProgram::log(QGLShaderProgram* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->log()); | ||||
} | ||||
int PythonQtWrapper_QGLShaderProgram::maxGeometryOutputVertices(QGLShaderProgram* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->maxGeometryOutputVertices()); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::release(QGLShaderProgram* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->release()); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::removeAllShaders(QGLShaderProgram* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->removeAllShaders()); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::removeShader(QGLShaderProgram* theWrappedObject, QGLShader* shader) | ||||
{ | ||||
( theWrappedObject->removeShader(shader)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setAttributeArray(QGLShaderProgram* theWrappedObject, const char* name, const QVector2D* values, int stride) | ||||
{ | ||||
( theWrappedObject->setAttributeArray(name, values, stride)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setAttributeArray(QGLShaderProgram* theWrappedObject, const char* name, const QVector3D* values, int stride) | ||||
{ | ||||
( theWrappedObject->setAttributeArray(name, values, stride)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setAttributeArray(QGLShaderProgram* theWrappedObject, const char* name, const QVector4D* values, int stride) | ||||
{ | ||||
( theWrappedObject->setAttributeArray(name, values, stride)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setAttributeArray(QGLShaderProgram* theWrappedObject, int location, const QVector2D* values, int stride) | ||||
{ | ||||
( theWrappedObject->setAttributeArray(location, values, stride)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setAttributeArray(QGLShaderProgram* theWrappedObject, int location, const QVector3D* values, int stride) | ||||
{ | ||||
( theWrappedObject->setAttributeArray(location, values, stride)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setAttributeArray(QGLShaderProgram* theWrappedObject, int location, const QVector4D* values, int stride) | ||||
{ | ||||
( theWrappedObject->setAttributeArray(location, values, stride)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setAttributeValue(QGLShaderProgram* theWrappedObject, const char* name, const QColor& value) | ||||
{ | ||||
( theWrappedObject->setAttributeValue(name, value)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setAttributeValue(QGLShaderProgram* theWrappedObject, const char* name, const QVector2D& value) | ||||
{ | ||||
( theWrappedObject->setAttributeValue(name, value)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setAttributeValue(QGLShaderProgram* theWrappedObject, const char* name, const QVector3D& value) | ||||
{ | ||||
( theWrappedObject->setAttributeValue(name, value)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setAttributeValue(QGLShaderProgram* theWrappedObject, const char* name, const QVector4D& value) | ||||
{ | ||||
( theWrappedObject->setAttributeValue(name, value)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setAttributeValue(QGLShaderProgram* theWrappedObject, int location, const QColor& value) | ||||
{ | ||||
( theWrappedObject->setAttributeValue(location, value)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setAttributeValue(QGLShaderProgram* theWrappedObject, int location, const QVector2D& value) | ||||
{ | ||||
( theWrappedObject->setAttributeValue(location, value)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setAttributeValue(QGLShaderProgram* theWrappedObject, int location, const QVector3D& value) | ||||
{ | ||||
( theWrappedObject->setAttributeValue(location, value)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setAttributeValue(QGLShaderProgram* theWrappedObject, int location, const QVector4D& value) | ||||
{ | ||||
( theWrappedObject->setAttributeValue(location, value)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setGeometryOutputVertexCount(QGLShaderProgram* theWrappedObject, int count) | ||||
{ | ||||
( theWrappedObject->setGeometryOutputVertexCount(count)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setUniformValue(QGLShaderProgram* theWrappedObject, const char* name, const QColor& color) | ||||
{ | ||||
( theWrappedObject->setUniformValue(name, color)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setUniformValue(QGLShaderProgram* theWrappedObject, const char* name, const QMatrix3x3& value) | ||||
{ | ||||
( theWrappedObject->setUniformValue(name, value)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setUniformValue(QGLShaderProgram* theWrappedObject, const char* name, const QMatrix4x4& value) | ||||
{ | ||||
( theWrappedObject->setUniformValue(name, value)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setUniformValue(QGLShaderProgram* theWrappedObject, const char* name, const QPoint& point) | ||||
{ | ||||
( theWrappedObject->setUniformValue(name, point)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setUniformValue(QGLShaderProgram* theWrappedObject, const char* name, const QPointF& point) | ||||
{ | ||||
( theWrappedObject->setUniformValue(name, point)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setUniformValue(QGLShaderProgram* theWrappedObject, const char* name, const QSize& size) | ||||
{ | ||||
( theWrappedObject->setUniformValue(name, size)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setUniformValue(QGLShaderProgram* theWrappedObject, const char* name, const QSizeF& size) | ||||
{ | ||||
( theWrappedObject->setUniformValue(name, size)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setUniformValue(QGLShaderProgram* theWrappedObject, const char* name, const QTransform& value) | ||||
{ | ||||
( theWrappedObject->setUniformValue(name, value)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setUniformValue(QGLShaderProgram* theWrappedObject, const char* name, const QVector2D& value) | ||||
{ | ||||
( theWrappedObject->setUniformValue(name, value)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setUniformValue(QGLShaderProgram* theWrappedObject, const char* name, const QVector3D& value) | ||||
{ | ||||
( theWrappedObject->setUniformValue(name, value)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setUniformValue(QGLShaderProgram* theWrappedObject, const char* name, const QVector4D& value) | ||||
{ | ||||
( theWrappedObject->setUniformValue(name, value)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setUniformValue(QGLShaderProgram* theWrappedObject, int location, const QColor& color) | ||||
{ | ||||
( theWrappedObject->setUniformValue(location, color)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setUniformValue(QGLShaderProgram* theWrappedObject, int location, const QMatrix3x3& value) | ||||
{ | ||||
( theWrappedObject->setUniformValue(location, value)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setUniformValue(QGLShaderProgram* theWrappedObject, int location, const QMatrix4x4& value) | ||||
{ | ||||
( theWrappedObject->setUniformValue(location, value)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setUniformValue(QGLShaderProgram* theWrappedObject, int location, const QPoint& point) | ||||
{ | ||||
( theWrappedObject->setUniformValue(location, point)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setUniformValue(QGLShaderProgram* theWrappedObject, int location, const QPointF& point) | ||||
{ | ||||
( theWrappedObject->setUniformValue(location, point)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setUniformValue(QGLShaderProgram* theWrappedObject, int location, const QSize& size) | ||||
{ | ||||
( theWrappedObject->setUniformValue(location, size)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setUniformValue(QGLShaderProgram* theWrappedObject, int location, const QSizeF& size) | ||||
{ | ||||
( theWrappedObject->setUniformValue(location, size)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setUniformValue(QGLShaderProgram* theWrappedObject, int location, const QTransform& value) | ||||
{ | ||||
( theWrappedObject->setUniformValue(location, value)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setUniformValue(QGLShaderProgram* theWrappedObject, int location, const QVector2D& value) | ||||
{ | ||||
( theWrappedObject->setUniformValue(location, value)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setUniformValue(QGLShaderProgram* theWrappedObject, int location, const QVector3D& value) | ||||
{ | ||||
( theWrappedObject->setUniformValue(location, value)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setUniformValue(QGLShaderProgram* theWrappedObject, int location, const QVector4D& value) | ||||
{ | ||||
( theWrappedObject->setUniformValue(location, value)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setUniformValueArray(QGLShaderProgram* theWrappedObject, const char* name, const QMatrix3x3* values, int count) | ||||
{ | ||||
( theWrappedObject->setUniformValueArray(name, values, count)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setUniformValueArray(QGLShaderProgram* theWrappedObject, const char* name, const QMatrix4x4* values, int count) | ||||
{ | ||||
( theWrappedObject->setUniformValueArray(name, values, count)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setUniformValueArray(QGLShaderProgram* theWrappedObject, const char* name, const QVector2D* values, int count) | ||||
{ | ||||
( theWrappedObject->setUniformValueArray(name, values, count)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setUniformValueArray(QGLShaderProgram* theWrappedObject, const char* name, const QVector3D* values, int count) | ||||
{ | ||||
( theWrappedObject->setUniformValueArray(name, values, count)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setUniformValueArray(QGLShaderProgram* theWrappedObject, const char* name, const QVector4D* values, int count) | ||||
{ | ||||
( theWrappedObject->setUniformValueArray(name, values, count)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setUniformValueArray(QGLShaderProgram* theWrappedObject, int location, const QMatrix3x3* values, int count) | ||||
{ | ||||
( theWrappedObject->setUniformValueArray(location, values, count)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setUniformValueArray(QGLShaderProgram* theWrappedObject, int location, const QMatrix4x4* values, int count) | ||||
{ | ||||
( theWrappedObject->setUniformValueArray(location, values, count)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setUniformValueArray(QGLShaderProgram* theWrappedObject, int location, const QVector2D* values, int count) | ||||
{ | ||||
( theWrappedObject->setUniformValueArray(location, values, count)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setUniformValueArray(QGLShaderProgram* theWrappedObject, int location, const QVector3D* values, int count) | ||||
{ | ||||
( theWrappedObject->setUniformValueArray(location, values, count)); | ||||
} | ||||
void PythonQtWrapper_QGLShaderProgram::setUniformValueArray(QGLShaderProgram* theWrappedObject, int location, const QVector4D* values, int count) | ||||
{ | ||||
( theWrappedObject->setUniformValueArray(location, values, count)); | ||||
} | ||||
QList<QGLShader* > PythonQtWrapper_QGLShaderProgram::shaders(QGLShaderProgram* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->shaders()); | ||||
} | ||||
int PythonQtWrapper_QGLShaderProgram::uniformLocation(QGLShaderProgram* theWrappedObject, const QByteArray& name) const | ||||
{ | ||||
return ( theWrappedObject->uniformLocation(name)); | ||||
} | ||||
int PythonQtWrapper_QGLShaderProgram::uniformLocation(QGLShaderProgram* theWrappedObject, const QString& name) const | ||||
{ | ||||
return ( theWrappedObject->uniformLocation(name)); | ||||
} | ||||
int PythonQtWrapper_QGLShaderProgram::uniformLocation(QGLShaderProgram* theWrappedObject, const char* name) const | ||||
{ | ||||
return ( theWrappedObject->uniformLocation(name)); | ||||
} | ||||
PythonQtShell_QGLWidget::~PythonQtShell_QGLWidget() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_QGLWidget::actionEvent(QActionEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "actionEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QActionEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLWidget::actionEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QGLWidget::changeEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "changeEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLWidget::changeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QGLWidget::childEvent(QChildEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QChildEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLWidget::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QGLWidget::closeEvent(QCloseEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "closeEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QCloseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLWidget::closeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QGLWidget::contextMenuEvent(QContextMenuEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "contextMenuEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QContextMenuEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLWidget::contextMenuEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QGLWidget::customEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLWidget::customEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QGLWidget::devType() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "devType"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
int returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result); | ||||
} else { | ||||
returnValue = *((int*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QGLWidget::devType(); | ||||
} | ||||
void PythonQtShell_QGLWidget::dragEnterEvent(QDragEnterEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragEnterEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QDragEnterEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLWidget::dragEnterEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QGLWidget::dragLeaveEvent(QDragLeaveEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragLeaveEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QDragLeaveEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLWidget::dragLeaveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QGLWidget::dragMoveEvent(QDragMoveEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dragMoveEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QDragMoveEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLWidget::dragMoveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QGLWidget::dropEvent(QDropEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QDropEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLWidget::dropEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QGLWidget::enterEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enterEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLWidget::enterEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QGLWidget::event(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "QEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QGLWidget::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QGLWidget::eventFilter(QObject* arg__1, QEvent* arg__2) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
bool returnValue; | ||||
void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QGLWidget::eventFilter(arg__1, arg__2); | ||||
} | ||||
void PythonQtShell_QGLWidget::focusInEvent(QFocusEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusInEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QFocusEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLWidget::focusInEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QGLWidget::focusNextPrevChild(bool next) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusNextPrevChild"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&next}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QGLWidget::focusNextPrevChild(next); | ||||
} | ||||
void PythonQtShell_QGLWidget::focusOutEvent(QFocusEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "focusOutEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QFocusEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLWidget::focusOutEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QGLWidget::glDraw() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "glDraw"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={""}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLWidget::glDraw(); | ||||
} | ||||
void PythonQtShell_QGLWidget::glInit() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "glInit"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={""}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLWidget::glInit(); | ||||
} | ||||
bool PythonQtShell_QGLWidget::hasHeightForWidth() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasHeightForWidth"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
bool returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QGLWidget::hasHeightForWidth(); | ||||
} | ||||
int PythonQtShell_QGLWidget::heightForWidth(int arg__1) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "heightForWidth"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"int" , "int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
int returnValue; | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result); | ||||
} else { | ||||
returnValue = *((int*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QGLWidget::heightForWidth(arg__1); | ||||
} | ||||
void PythonQtShell_QGLWidget::hideEvent(QHideEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hideEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QHideEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLWidget::hideEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QGLWidget::initPainter(QPainter* painter) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initPainter"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&painter}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLWidget::initPainter(painter); | ||||
} | ||||
void PythonQtShell_QGLWidget::initializeGL() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initializeGL"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={""}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLWidget::initializeGL(); | ||||
} | ||||
void PythonQtShell_QGLWidget::initializeOverlayGL() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initializeOverlayGL"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={""}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLWidget::initializeOverlayGL(); | ||||
} | ||||
void PythonQtShell_QGLWidget::inputMethodEvent(QInputMethodEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QInputMethodEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLWidget::inputMethodEvent(arg__1); | ||||
} | ||||
QVariant PythonQtShell_QGLWidget::inputMethodQuery(Qt::InputMethodQuery arg__1) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "inputMethodQuery"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QVariant returnValue; | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QVariant*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QGLWidget::inputMethodQuery(arg__1); | ||||
} | ||||
void PythonQtShell_QGLWidget::keyPressEvent(QKeyEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyPressEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QKeyEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLWidget::keyPressEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QGLWidget::keyReleaseEvent(QKeyEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keyReleaseEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QKeyEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLWidget::keyReleaseEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QGLWidget::leaveEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "leaveEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLWidget::leaveEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QGLWidget::metric(QPaintDevice::PaintDeviceMetric arg__1) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metric"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
int returnValue; | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result); | ||||
} else { | ||||
returnValue = *((int*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QGLWidget::metric(arg__1); | ||||
} | ||||
QSize PythonQtShell_QGLWidget::minimumSizeHint() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getMinimumSizeHint"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QSize"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QSize returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QSize*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QGLWidget::minimumSizeHint(); | ||||
} | ||||
void PythonQtShell_QGLWidget::mouseDoubleClickEvent(QMouseEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseDoubleClickEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLWidget::mouseDoubleClickEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QGLWidget::mouseMoveEvent(QMouseEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseMoveEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLWidget::mouseMoveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QGLWidget::mousePressEvent(QMouseEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mousePressEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLWidget::mousePressEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QGLWidget::mouseReleaseEvent(QMouseEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mouseReleaseEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QMouseEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLWidget::mouseReleaseEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QGLWidget::moveEvent(QMoveEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "moveEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QMoveEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLWidget::moveEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QGLWidget::nativeEvent(const QByteArray& eventType, void* message, long* result) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nativeEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
bool returnValue; | ||||
void* args[4] = {NULL, (void*)&eventType, (void*)&message, (void*)&result}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QGLWidget::nativeEvent(eventType, message, result); | ||||
} | ||||
QPaintEngine* PythonQtShell_QGLWidget::paintEngine() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEngine"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QPaintEngine*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QPaintEngine* returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QPaintEngine**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QGLWidget::paintEngine(); | ||||
} | ||||
void PythonQtShell_QGLWidget::paintEvent(QPaintEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QPaintEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLWidget::paintEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QGLWidget::paintGL() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintGL"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={""}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLWidget::paintGL(); | ||||
} | ||||
void PythonQtShell_QGLWidget::paintOverlayGL() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paintOverlayGL"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={""}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLWidget::paintOverlayGL(); | ||||
} | ||||
QPaintDevice* PythonQtShell_QGLWidget::redirected(QPoint* offset) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "redirected"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QPaintDevice* returnValue; | ||||
void* args[2] = {NULL, (void*)&offset}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QPaintDevice**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QGLWidget::redirected(offset); | ||||
} | ||||
void PythonQtShell_QGLWidget::resizeEvent(QResizeEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QResizeEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLWidget::resizeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QGLWidget::resizeGL(int w, int h) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeGL"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "int" , "int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
void* args[3] = {NULL, (void*)&w, (void*)&h}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLWidget::resizeGL(w, h); | ||||
} | ||||
void PythonQtShell_QGLWidget::resizeOverlayGL(int w, int h) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resizeOverlayGL"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "int" , "int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
void* args[3] = {NULL, (void*)&w, (void*)&h}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLWidget::resizeOverlayGL(w, h); | ||||
} | ||||
QPainter* PythonQtShell_QGLWidget::sharedPainter() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sharedPainter"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QPainter*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QPainter* returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QPainter**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QGLWidget::sharedPainter(); | ||||
} | ||||
void PythonQtShell_QGLWidget::showEvent(QShowEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "showEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QShowEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLWidget::showEvent(arg__1); | ||||
} | ||||
QSize PythonQtShell_QGLWidget::sizeHint() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "getSizeHint"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QSize"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QSize returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QSize*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QGLWidget::sizeHint(); | ||||
} | ||||
void PythonQtShell_QGLWidget::tabletEvent(QTabletEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "tabletEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QTabletEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLWidget::tabletEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QGLWidget::timerEvent(QTimerEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QTimerEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLWidget::timerEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QGLWidget::updateGL() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateGL"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={""}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLWidget::updateGL(); | ||||
} | ||||
void PythonQtShell_QGLWidget::updateOverlayGL() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateOverlayGL"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={""}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLWidget::updateOverlayGL(); | ||||
} | ||||
void PythonQtShell_QGLWidget::wheelEvent(QWheelEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "wheelEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QWheelEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QGLWidget::wheelEvent(arg__1); | ||||
} | ||||
QGLWidget* PythonQtWrapper_QGLWidget::new_QGLWidget(QGLContext* context, QWidget* parent, const QGLWidget* shareWidget, Qt::WindowFlags f) | ||||
{ | ||||
return new PythonQtShell_QGLWidget(context, parent, shareWidget, f); } | ||||
QGLWidget* PythonQtWrapper_QGLWidget::new_QGLWidget(QWidget* parent, const QGLWidget* shareWidget, Qt::WindowFlags f) | ||||
{ | ||||
return new PythonQtShell_QGLWidget(parent, shareWidget, f); } | ||||
QGLWidget* PythonQtWrapper_QGLWidget::new_QGLWidget(const QGLFormat& format, QWidget* parent, const QGLWidget* shareWidget, Qt::WindowFlags f) | ||||
{ | ||||
return new PythonQtShell_QGLWidget(format, parent, shareWidget, f); } | ||||
const QGLColormap* PythonQtWrapper_QGLWidget::colormap(QGLWidget* theWrappedObject) const | ||||
{ | ||||
return &( theWrappedObject->colormap()); | ||||
} | ||||
QGLContext* PythonQtWrapper_QGLWidget::context(QGLWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->context()); | ||||
} | ||||
QImage PythonQtWrapper_QGLWidget::static_QGLWidget_convertToGLFormat(const QImage& img) | ||||
{ | ||||
return (QGLWidget::convertToGLFormat(img)); | ||||
} | ||||
void PythonQtWrapper_QGLWidget::doneCurrent(QGLWidget* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->doneCurrent()); | ||||
} | ||||
bool PythonQtWrapper_QGLWidget::doubleBuffer(QGLWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->doubleBuffer()); | ||||
} | ||||
bool PythonQtWrapper_QGLWidget::event(QGLWidget* theWrappedObject, QEvent* arg__1) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QGLWidget*)theWrappedObject)->promoted_event(arg__1)); | ||||
} | ||||
QGLFormat PythonQtWrapper_QGLWidget::format(QGLWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->format()); | ||||
} | ||||
void PythonQtWrapper_QGLWidget::glDraw(QGLWidget* theWrappedObject) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QGLWidget*)theWrappedObject)->promoted_glDraw()); | ||||
} | ||||
void PythonQtWrapper_QGLWidget::glInit(QGLWidget* theWrappedObject) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QGLWidget*)theWrappedObject)->promoted_glInit()); | ||||
} | ||||
QImage PythonQtWrapper_QGLWidget::grabFrameBuffer(QGLWidget* theWrappedObject, bool withAlpha) | ||||
{ | ||||
return ( theWrappedObject->grabFrameBuffer(withAlpha)); | ||||
} | ||||
void PythonQtWrapper_QGLWidget::initializeGL(QGLWidget* theWrappedObject) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QGLWidget*)theWrappedObject)->promoted_initializeGL()); | ||||
} | ||||
void PythonQtWrapper_QGLWidget::initializeOverlayGL(QGLWidget* theWrappedObject) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QGLWidget*)theWrappedObject)->promoted_initializeOverlayGL()); | ||||
} | ||||
bool PythonQtWrapper_QGLWidget::isSharing(QGLWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isSharing()); | ||||
} | ||||
bool PythonQtWrapper_QGLWidget::isValid(QGLWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isValid()); | ||||
} | ||||
void PythonQtWrapper_QGLWidget::makeCurrent(QGLWidget* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->makeCurrent()); | ||||
} | ||||
void PythonQtWrapper_QGLWidget::makeOverlayCurrent(QGLWidget* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->makeOverlayCurrent()); | ||||
} | ||||
const QGLContext* PythonQtWrapper_QGLWidget::overlayContext(QGLWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->overlayContext()); | ||||
} | ||||
QPaintEngine* PythonQtWrapper_QGLWidget::paintEngine(QGLWidget* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QGLWidget*)theWrappedObject)->promoted_paintEngine()); | ||||
} | ||||
void PythonQtWrapper_QGLWidget::paintEvent(QGLWidget* theWrappedObject, QPaintEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QGLWidget*)theWrappedObject)->promoted_paintEvent(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QGLWidget::paintGL(QGLWidget* theWrappedObject) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QGLWidget*)theWrappedObject)->promoted_paintGL()); | ||||
} | ||||
void PythonQtWrapper_QGLWidget::paintOverlayGL(QGLWidget* theWrappedObject) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QGLWidget*)theWrappedObject)->promoted_paintOverlayGL()); | ||||
} | ||||
void PythonQtWrapper_QGLWidget::qglClearColor(QGLWidget* theWrappedObject, const QColor& c) const | ||||
{ | ||||
( theWrappedObject->qglClearColor(c)); | ||||
} | ||||
void PythonQtWrapper_QGLWidget::qglColor(QGLWidget* theWrappedObject, const QColor& c) const | ||||
{ | ||||
( theWrappedObject->qglColor(c)); | ||||
} | ||||
QPixmap PythonQtWrapper_QGLWidget::renderPixmap(QGLWidget* theWrappedObject, int w, int h, bool useContext) | ||||
{ | ||||
return ( theWrappedObject->renderPixmap(w, h, useContext)); | ||||
} | ||||
void PythonQtWrapper_QGLWidget::renderText(QGLWidget* theWrappedObject, double x, double y, double z, const QString& str, const QFont& fnt) | ||||
{ | ||||
( theWrappedObject->renderText(x, y, z, str, fnt)); | ||||
} | ||||
void PythonQtWrapper_QGLWidget::renderText(QGLWidget* theWrappedObject, int x, int y, const QString& str, const QFont& fnt) | ||||
{ | ||||
( theWrappedObject->renderText(x, y, str, fnt)); | ||||
} | ||||
void PythonQtWrapper_QGLWidget::resizeEvent(QGLWidget* theWrappedObject, QResizeEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QGLWidget*)theWrappedObject)->promoted_resizeEvent(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QGLWidget::resizeGL(QGLWidget* theWrappedObject, int w, int h) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QGLWidget*)theWrappedObject)->promoted_resizeGL(w, h)); | ||||
} | ||||
void PythonQtWrapper_QGLWidget::resizeOverlayGL(QGLWidget* theWrappedObject, int w, int h) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QGLWidget*)theWrappedObject)->promoted_resizeOverlayGL(w, h)); | ||||
} | ||||
void PythonQtWrapper_QGLWidget::setColormap(QGLWidget* theWrappedObject, const QGLColormap& map) | ||||
{ | ||||
( theWrappedObject->setColormap(map)); | ||||
} | ||||
void PythonQtWrapper_QGLWidget::swapBuffers(QGLWidget* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->swapBuffers()); | ||||
} | ||||
void PythonQtWrapper_QGLWidget::updateGL(QGLWidget* theWrappedObject) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QGLWidget*)theWrappedObject)->promoted_updateGL()); | ||||
} | ||||
void PythonQtWrapper_QGLWidget::updateOverlayGL(QGLWidget* theWrappedObject) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QGLWidget*)theWrappedObject)->promoted_updateOverlayGL()); | ||||
} | ||||