com_trolltech_qt_gui11.cpp
7268 lines
| 251.6 KiB
| text/x-c
|
CppLexer
florianlink
|
r186 | #include "com_trolltech_qt_gui11.h" | ||
#include <PythonQtConversion.h> | ||||
#include <PythonQtMethodInfo.h> | ||||
#include <PythonQtSignalReceiver.h> | ||||
#include <QIcon> | ||||
#include <QMessageBox> | ||||
#include <QVariant> | ||||
#include <qabstractbutton.h> | ||||
#include <qaction.h> | ||||
#include <qactiongroup.h> | ||||
#include <qapplication.h> | ||||
#include <qbitmap.h> | ||||
#include <qbrush.h> | ||||
#include <qbytearray.h> | ||||
#include <qcoreevent.h> | ||||
#include <qcursor.h> | ||||
#include <qdatastream.h> | ||||
#include <qevent.h> | ||||
#include <qfont.h> | ||||
#include <qgraphicseffect.h> | ||||
#include <qgraphicsproxywidget.h> | ||||
#include <qgraphicswidget.h> | ||||
#include <qicon.h> | ||||
#include <qinputcontext.h> | ||||
#include <qkeysequence.h> | ||||
#include <qlayout.h> | ||||
#include <qlayoutitem.h> | ||||
#include <qlist.h> | ||||
#include <qlocale.h> | ||||
#include <qmargins.h> | ||||
#include <qmatrix4x4.h> | ||||
#include <qmenu.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 <qstyleoption.h> | ||||
#include <qvalidator.h> | ||||
#include <qvector2d.h> | ||||
#include <qvector3d.h> | ||||
#include <qvector4d.h> | ||||
#include <qwidget.h> | ||||
#include <qwidgetaction.h> | ||||
#include <qwindowsstyle.h> | ||||
#include <qwizard.h> | ||||
#include <qworkspace.h> | ||||
PythonQtShell_QValidator::~PythonQtShell_QValidator() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_QValidator::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; | ||||
} | ||||
} | ||||
QValidator::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QValidator::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; | ||||
} | ||||
} | ||||
QValidator::customEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QValidator::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 QValidator::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QValidator::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 QValidator::eventFilter(arg__1, arg__2); | ||||
} | ||||
void PythonQtShell_QValidator::fixup(QString& arg__1) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "fixup"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QString&"}; | ||||
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; | ||||
} | ||||
} | ||||
QValidator::fixup(arg__1); | ||||
} | ||||
void PythonQtShell_QValidator::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; | ||||
} | ||||
} | ||||
QValidator::timerEvent(arg__1); | ||||
} | ||||
QValidator::State PythonQtShell_QValidator::validate(QString& arg__1, int& arg__2) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "validate"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QValidator::State" , "QString&" , "int&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
QValidator::State 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("validate", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QValidator::State*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QValidator::State(); | ||||
} | ||||
QValidator* PythonQtWrapper_QValidator::new_QValidator(QObject* parent) | ||||
{ | ||||
return new PythonQtShell_QValidator(parent); } | ||||
void PythonQtWrapper_QValidator::fixup(QValidator* theWrappedObject, QString& arg__1) const | ||||
{ | ||||
( ((PythonQtPublicPromoter_QValidator*)theWrappedObject)->promoted_fixup(arg__1)); | ||||
} | ||||
QLocale PythonQtWrapper_QValidator::locale(QValidator* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->locale()); | ||||
} | ||||
void PythonQtWrapper_QValidator::setLocale(QValidator* theWrappedObject, const QLocale& locale) | ||||
{ | ||||
( theWrappedObject->setLocale(locale)); | ||||
} | ||||
QVector2D* PythonQtWrapper_QVector2D::new_QVector2D() | ||||
{ | ||||
return new QVector2D(); } | ||||
QVector2D* PythonQtWrapper_QVector2D::new_QVector2D(const QPoint& point) | ||||
{ | ||||
return new QVector2D(point); } | ||||
QVector2D* PythonQtWrapper_QVector2D::new_QVector2D(const QPointF& point) | ||||
{ | ||||
return new QVector2D(point); } | ||||
QVector2D* PythonQtWrapper_QVector2D::new_QVector2D(const QVector3D& vector) | ||||
{ | ||||
return new QVector2D(vector); } | ||||
QVector2D* PythonQtWrapper_QVector2D::new_QVector2D(const QVector4D& vector) | ||||
{ | ||||
return new QVector2D(vector); } | ||||
QVector2D* PythonQtWrapper_QVector2D::new_QVector2D(qreal xpos, qreal ypos) | ||||
{ | ||||
return new QVector2D(xpos, ypos); } | ||||
qreal PythonQtWrapper_QVector2D::static_QVector2D_dotProduct(const QVector2D& v1, const QVector2D& v2) | ||||
{ | ||||
return (QVector2D::dotProduct(v1, v2)); | ||||
} | ||||
bool PythonQtWrapper_QVector2D::isNull(QVector2D* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isNull()); | ||||
} | ||||
qreal PythonQtWrapper_QVector2D::length(QVector2D* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->length()); | ||||
} | ||||
qreal PythonQtWrapper_QVector2D::lengthSquared(QVector2D* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->lengthSquared()); | ||||
} | ||||
void PythonQtWrapper_QVector2D::normalize(QVector2D* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->normalize()); | ||||
} | ||||
QVector2D PythonQtWrapper_QVector2D::normalized(QVector2D* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->normalized()); | ||||
} | ||||
const QVector2D PythonQtWrapper_QVector2D::__mul__(QVector2D* theWrappedObject, const QVector2D& v2) | ||||
{ | ||||
return ( (*theWrappedObject)* v2); | ||||
} | ||||
const QVector2D PythonQtWrapper_QVector2D::__mul__(QVector2D* theWrappedObject, qreal factor) | ||||
{ | ||||
return ( (*theWrappedObject)* factor); | ||||
} | ||||
QVector2D* PythonQtWrapper_QVector2D::__imul__(QVector2D* theWrappedObject, const QVector2D& vector) | ||||
{ | ||||
return &( (*theWrappedObject)*= vector); | ||||
} | ||||
QVector2D* PythonQtWrapper_QVector2D::__imul__(QVector2D* theWrappedObject, qreal factor) | ||||
{ | ||||
return &( (*theWrappedObject)*= factor); | ||||
} | ||||
const QVector2D PythonQtWrapper_QVector2D::__add__(QVector2D* theWrappedObject, const QVector2D& v2) | ||||
{ | ||||
return ( (*theWrappedObject)+ v2); | ||||
} | ||||
QVector2D* PythonQtWrapper_QVector2D::__iadd__(QVector2D* theWrappedObject, const QVector2D& vector) | ||||
{ | ||||
return &( (*theWrappedObject)+= vector); | ||||
} | ||||
const QVector2D PythonQtWrapper_QVector2D::__sub__(QVector2D* theWrappedObject, const QVector2D& v2) | ||||
{ | ||||
return ( (*theWrappedObject)- v2); | ||||
} | ||||
QVector2D* PythonQtWrapper_QVector2D::__isub__(QVector2D* theWrappedObject, const QVector2D& vector) | ||||
{ | ||||
return &( (*theWrappedObject)-= vector); | ||||
} | ||||
const QVector2D PythonQtWrapper_QVector2D::__div__(QVector2D* theWrappedObject, qreal divisor) | ||||
{ | ||||
return ( (*theWrappedObject)/ divisor); | ||||
} | ||||
QVector2D* PythonQtWrapper_QVector2D::__idiv__(QVector2D* theWrappedObject, qreal divisor) | ||||
{ | ||||
return &( (*theWrappedObject)/= divisor); | ||||
} | ||||
void PythonQtWrapper_QVector2D::writeTo(QVector2D* theWrappedObject, QDataStream& arg__1) | ||||
{ | ||||
arg__1 << (*theWrappedObject); | ||||
} | ||||
bool PythonQtWrapper_QVector2D::__eq__(QVector2D* theWrappedObject, const QVector2D& v2) | ||||
{ | ||||
return ( (*theWrappedObject)== v2); | ||||
} | ||||
void PythonQtWrapper_QVector2D::readFrom(QVector2D* theWrappedObject, QDataStream& arg__1) | ||||
{ | ||||
arg__1 >> (*theWrappedObject); | ||||
} | ||||
void PythonQtWrapper_QVector2D::setX(QVector2D* theWrappedObject, qreal x) | ||||
{ | ||||
( theWrappedObject->setX(x)); | ||||
} | ||||
void PythonQtWrapper_QVector2D::setY(QVector2D* theWrappedObject, qreal y) | ||||
{ | ||||
( theWrappedObject->setY(y)); | ||||
} | ||||
QPoint PythonQtWrapper_QVector2D::toPoint(QVector2D* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->toPoint()); | ||||
} | ||||
QPointF PythonQtWrapper_QVector2D::toPointF(QVector2D* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->toPointF()); | ||||
} | ||||
QVector3D PythonQtWrapper_QVector2D::toVector3D(QVector2D* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->toVector3D()); | ||||
} | ||||
QVector4D PythonQtWrapper_QVector2D::toVector4D(QVector2D* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->toVector4D()); | ||||
} | ||||
qreal PythonQtWrapper_QVector2D::x(QVector2D* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->x()); | ||||
} | ||||
qreal PythonQtWrapper_QVector2D::y(QVector2D* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->y()); | ||||
} | ||||
QString PythonQtWrapper_QVector2D::py_toString(QVector2D* obj) { | ||||
QString result; | ||||
QDebug d(&result); | ||||
d << *obj; | ||||
return result; | ||||
} | ||||
QVector3D* PythonQtWrapper_QVector3D::new_QVector3D() | ||||
{ | ||||
return new QVector3D(); } | ||||
QVector3D* PythonQtWrapper_QVector3D::new_QVector3D(const QPoint& point) | ||||
{ | ||||
return new QVector3D(point); } | ||||
QVector3D* PythonQtWrapper_QVector3D::new_QVector3D(const QPointF& point) | ||||
{ | ||||
return new QVector3D(point); } | ||||
QVector3D* PythonQtWrapper_QVector3D::new_QVector3D(const QVector2D& vector) | ||||
{ | ||||
return new QVector3D(vector); } | ||||
QVector3D* PythonQtWrapper_QVector3D::new_QVector3D(const QVector2D& vector, qreal zpos) | ||||
{ | ||||
return new QVector3D(vector, zpos); } | ||||
QVector3D* PythonQtWrapper_QVector3D::new_QVector3D(const QVector4D& vector) | ||||
{ | ||||
return new QVector3D(vector); } | ||||
QVector3D* PythonQtWrapper_QVector3D::new_QVector3D(qreal xpos, qreal ypos, qreal zpos) | ||||
{ | ||||
return new QVector3D(xpos, ypos, zpos); } | ||||
QVector3D PythonQtWrapper_QVector3D::static_QVector3D_crossProduct(const QVector3D& v1, const QVector3D& v2) | ||||
{ | ||||
return (QVector3D::crossProduct(v1, v2)); | ||||
} | ||||
qreal PythonQtWrapper_QVector3D::distanceToLine(QVector3D* theWrappedObject, const QVector3D& point, const QVector3D& direction) const | ||||
{ | ||||
return ( theWrappedObject->distanceToLine(point, direction)); | ||||
} | ||||
qreal PythonQtWrapper_QVector3D::distanceToPlane(QVector3D* theWrappedObject, const QVector3D& plane, const QVector3D& normal) const | ||||
{ | ||||
return ( theWrappedObject->distanceToPlane(plane, normal)); | ||||
} | ||||
qreal PythonQtWrapper_QVector3D::distanceToPlane(QVector3D* theWrappedObject, const QVector3D& plane1, const QVector3D& plane2, const QVector3D& plane3) const | ||||
{ | ||||
return ( theWrappedObject->distanceToPlane(plane1, plane2, plane3)); | ||||
} | ||||
qreal PythonQtWrapper_QVector3D::static_QVector3D_dotProduct(const QVector3D& v1, const QVector3D& v2) | ||||
{ | ||||
return (QVector3D::dotProduct(v1, v2)); | ||||
} | ||||
bool PythonQtWrapper_QVector3D::isNull(QVector3D* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isNull()); | ||||
} | ||||
qreal PythonQtWrapper_QVector3D::length(QVector3D* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->length()); | ||||
} | ||||
qreal PythonQtWrapper_QVector3D::lengthSquared(QVector3D* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->lengthSquared()); | ||||
} | ||||
QVector3D PythonQtWrapper_QVector3D::static_QVector3D_normal(const QVector3D& v1, const QVector3D& v2) | ||||
{ | ||||
return (QVector3D::normal(v1, v2)); | ||||
} | ||||
QVector3D PythonQtWrapper_QVector3D::static_QVector3D_normal(const QVector3D& v1, const QVector3D& v2, const QVector3D& v3) | ||||
{ | ||||
return (QVector3D::normal(v1, v2, v3)); | ||||
} | ||||
void PythonQtWrapper_QVector3D::normalize(QVector3D* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->normalize()); | ||||
} | ||||
QVector3D PythonQtWrapper_QVector3D::normalized(QVector3D* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->normalized()); | ||||
} | ||||
QVector3D PythonQtWrapper_QVector3D::__mul__(QVector3D* theWrappedObject, const QMatrix4x4& matrix) | ||||
{ | ||||
return ( (*theWrappedObject)* matrix); | ||||
} | ||||
const QVector3D PythonQtWrapper_QVector3D::__mul__(QVector3D* theWrappedObject, const QVector3D& v2) | ||||
{ | ||||
return ( (*theWrappedObject)* v2); | ||||
} | ||||
const QVector3D PythonQtWrapper_QVector3D::__mul__(QVector3D* theWrappedObject, qreal factor) | ||||
{ | ||||
return ( (*theWrappedObject)* factor); | ||||
} | ||||
QVector3D* PythonQtWrapper_QVector3D::__imul__(QVector3D* theWrappedObject, const QVector3D& vector) | ||||
{ | ||||
return &( (*theWrappedObject)*= vector); | ||||
} | ||||
QVector3D* PythonQtWrapper_QVector3D::__imul__(QVector3D* theWrappedObject, qreal factor) | ||||
{ | ||||
return &( (*theWrappedObject)*= factor); | ||||
} | ||||
const QVector3D PythonQtWrapper_QVector3D::__add__(QVector3D* theWrappedObject, const QVector3D& v2) | ||||
{ | ||||
return ( (*theWrappedObject)+ v2); | ||||
} | ||||
QVector3D* PythonQtWrapper_QVector3D::__iadd__(QVector3D* theWrappedObject, const QVector3D& vector) | ||||
{ | ||||
return &( (*theWrappedObject)+= vector); | ||||
} | ||||
const QVector3D PythonQtWrapper_QVector3D::__sub__(QVector3D* theWrappedObject, const QVector3D& v2) | ||||
{ | ||||
return ( (*theWrappedObject)- v2); | ||||
} | ||||
QVector3D* PythonQtWrapper_QVector3D::__isub__(QVector3D* theWrappedObject, const QVector3D& vector) | ||||
{ | ||||
return &( (*theWrappedObject)-= vector); | ||||
} | ||||
const QVector3D PythonQtWrapper_QVector3D::__div__(QVector3D* theWrappedObject, qreal divisor) | ||||
{ | ||||
return ( (*theWrappedObject)/ divisor); | ||||
} | ||||
QVector3D* PythonQtWrapper_QVector3D::__idiv__(QVector3D* theWrappedObject, qreal divisor) | ||||
{ | ||||
return &( (*theWrappedObject)/= divisor); | ||||
} | ||||
void PythonQtWrapper_QVector3D::writeTo(QVector3D* theWrappedObject, QDataStream& arg__1) | ||||
{ | ||||
arg__1 << (*theWrappedObject); | ||||
} | ||||
bool PythonQtWrapper_QVector3D::__eq__(QVector3D* theWrappedObject, const QVector3D& v2) | ||||
{ | ||||
return ( (*theWrappedObject)== v2); | ||||
} | ||||
void PythonQtWrapper_QVector3D::readFrom(QVector3D* theWrappedObject, QDataStream& arg__1) | ||||
{ | ||||
arg__1 >> (*theWrappedObject); | ||||
} | ||||
void PythonQtWrapper_QVector3D::setX(QVector3D* theWrappedObject, qreal x) | ||||
{ | ||||
( theWrappedObject->setX(x)); | ||||
} | ||||
void PythonQtWrapper_QVector3D::setY(QVector3D* theWrappedObject, qreal y) | ||||
{ | ||||
( theWrappedObject->setY(y)); | ||||
} | ||||
void PythonQtWrapper_QVector3D::setZ(QVector3D* theWrappedObject, qreal z) | ||||
{ | ||||
( theWrappedObject->setZ(z)); | ||||
} | ||||
QPoint PythonQtWrapper_QVector3D::toPoint(QVector3D* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->toPoint()); | ||||
} | ||||
QPointF PythonQtWrapper_QVector3D::toPointF(QVector3D* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->toPointF()); | ||||
} | ||||
QVector2D PythonQtWrapper_QVector3D::toVector2D(QVector3D* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->toVector2D()); | ||||
} | ||||
QVector4D PythonQtWrapper_QVector3D::toVector4D(QVector3D* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->toVector4D()); | ||||
} | ||||
qreal PythonQtWrapper_QVector3D::x(QVector3D* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->x()); | ||||
} | ||||
qreal PythonQtWrapper_QVector3D::y(QVector3D* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->y()); | ||||
} | ||||
qreal PythonQtWrapper_QVector3D::z(QVector3D* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->z()); | ||||
} | ||||
QString PythonQtWrapper_QVector3D::py_toString(QVector3D* obj) { | ||||
QString result; | ||||
QDebug d(&result); | ||||
d << *obj; | ||||
return result; | ||||
} | ||||
QVector4D* PythonQtWrapper_QVector4D::new_QVector4D() | ||||
{ | ||||
return new QVector4D(); } | ||||
QVector4D* PythonQtWrapper_QVector4D::new_QVector4D(const QPoint& point) | ||||
{ | ||||
return new QVector4D(point); } | ||||
QVector4D* PythonQtWrapper_QVector4D::new_QVector4D(const QPointF& point) | ||||
{ | ||||
return new QVector4D(point); } | ||||
QVector4D* PythonQtWrapper_QVector4D::new_QVector4D(const QVector2D& vector) | ||||
{ | ||||
return new QVector4D(vector); } | ||||
QVector4D* PythonQtWrapper_QVector4D::new_QVector4D(const QVector2D& vector, qreal zpos, qreal wpos) | ||||
{ | ||||
return new QVector4D(vector, zpos, wpos); } | ||||
QVector4D* PythonQtWrapper_QVector4D::new_QVector4D(const QVector3D& vector) | ||||
{ | ||||
return new QVector4D(vector); } | ||||
QVector4D* PythonQtWrapper_QVector4D::new_QVector4D(const QVector3D& vector, qreal wpos) | ||||
{ | ||||
return new QVector4D(vector, wpos); } | ||||
QVector4D* PythonQtWrapper_QVector4D::new_QVector4D(qreal xpos, qreal ypos, qreal zpos, qreal wpos) | ||||
{ | ||||
return new QVector4D(xpos, ypos, zpos, wpos); } | ||||
qreal PythonQtWrapper_QVector4D::static_QVector4D_dotProduct(const QVector4D& v1, const QVector4D& v2) | ||||
{ | ||||
return (QVector4D::dotProduct(v1, v2)); | ||||
} | ||||
bool PythonQtWrapper_QVector4D::isNull(QVector4D* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isNull()); | ||||
} | ||||
qreal PythonQtWrapper_QVector4D::length(QVector4D* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->length()); | ||||
} | ||||
qreal PythonQtWrapper_QVector4D::lengthSquared(QVector4D* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->lengthSquared()); | ||||
} | ||||
void PythonQtWrapper_QVector4D::normalize(QVector4D* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->normalize()); | ||||
} | ||||
QVector4D PythonQtWrapper_QVector4D::normalized(QVector4D* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->normalized()); | ||||
} | ||||
QVector4D PythonQtWrapper_QVector4D::__mul__(QVector4D* theWrappedObject, const QMatrix4x4& matrix) | ||||
{ | ||||
return ( (*theWrappedObject)* matrix); | ||||
} | ||||
const QVector4D PythonQtWrapper_QVector4D::__mul__(QVector4D* theWrappedObject, const QVector4D& v2) | ||||
{ | ||||
return ( (*theWrappedObject)* v2); | ||||
} | ||||
const QVector4D PythonQtWrapper_QVector4D::__mul__(QVector4D* theWrappedObject, qreal factor) | ||||
{ | ||||
return ( (*theWrappedObject)* factor); | ||||
} | ||||
QVector4D* PythonQtWrapper_QVector4D::__imul__(QVector4D* theWrappedObject, const QVector4D& vector) | ||||
{ | ||||
return &( (*theWrappedObject)*= vector); | ||||
} | ||||
QVector4D* PythonQtWrapper_QVector4D::__imul__(QVector4D* theWrappedObject, qreal factor) | ||||
{ | ||||
return &( (*theWrappedObject)*= factor); | ||||
} | ||||
const QVector4D PythonQtWrapper_QVector4D::__add__(QVector4D* theWrappedObject, const QVector4D& v2) | ||||
{ | ||||
return ( (*theWrappedObject)+ v2); | ||||
} | ||||
QVector4D* PythonQtWrapper_QVector4D::__iadd__(QVector4D* theWrappedObject, const QVector4D& vector) | ||||
{ | ||||
return &( (*theWrappedObject)+= vector); | ||||
} | ||||
const QVector4D PythonQtWrapper_QVector4D::__sub__(QVector4D* theWrappedObject, const QVector4D& v2) | ||||
{ | ||||
return ( (*theWrappedObject)- v2); | ||||
} | ||||
QVector4D* PythonQtWrapper_QVector4D::__isub__(QVector4D* theWrappedObject, const QVector4D& vector) | ||||
{ | ||||
return &( (*theWrappedObject)-= vector); | ||||
} | ||||
const QVector4D PythonQtWrapper_QVector4D::__div__(QVector4D* theWrappedObject, qreal divisor) | ||||
{ | ||||
return ( (*theWrappedObject)/ divisor); | ||||
} | ||||
QVector4D* PythonQtWrapper_QVector4D::__idiv__(QVector4D* theWrappedObject, qreal divisor) | ||||
{ | ||||
return &( (*theWrappedObject)/= divisor); | ||||
} | ||||
void PythonQtWrapper_QVector4D::writeTo(QVector4D* theWrappedObject, QDataStream& arg__1) | ||||
{ | ||||
arg__1 << (*theWrappedObject); | ||||
} | ||||
bool PythonQtWrapper_QVector4D::__eq__(QVector4D* theWrappedObject, const QVector4D& v2) | ||||
{ | ||||
return ( (*theWrappedObject)== v2); | ||||
} | ||||
void PythonQtWrapper_QVector4D::readFrom(QVector4D* theWrappedObject, QDataStream& arg__1) | ||||
{ | ||||
arg__1 >> (*theWrappedObject); | ||||
} | ||||
void PythonQtWrapper_QVector4D::setW(QVector4D* theWrappedObject, qreal w) | ||||
{ | ||||
( theWrappedObject->setW(w)); | ||||
} | ||||
void PythonQtWrapper_QVector4D::setX(QVector4D* theWrappedObject, qreal x) | ||||
{ | ||||
( theWrappedObject->setX(x)); | ||||
} | ||||
void PythonQtWrapper_QVector4D::setY(QVector4D* theWrappedObject, qreal y) | ||||
{ | ||||
( theWrappedObject->setY(y)); | ||||
} | ||||
void PythonQtWrapper_QVector4D::setZ(QVector4D* theWrappedObject, qreal z) | ||||
{ | ||||
( theWrappedObject->setZ(z)); | ||||
} | ||||
QPoint PythonQtWrapper_QVector4D::toPoint(QVector4D* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->toPoint()); | ||||
} | ||||
QPointF PythonQtWrapper_QVector4D::toPointF(QVector4D* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->toPointF()); | ||||
} | ||||
QVector2D PythonQtWrapper_QVector4D::toVector2D(QVector4D* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->toVector2D()); | ||||
} | ||||
QVector2D PythonQtWrapper_QVector4D::toVector2DAffine(QVector4D* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->toVector2DAffine()); | ||||
} | ||||
QVector3D PythonQtWrapper_QVector4D::toVector3D(QVector4D* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->toVector3D()); | ||||
} | ||||
QVector3D PythonQtWrapper_QVector4D::toVector3DAffine(QVector4D* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->toVector3DAffine()); | ||||
} | ||||
qreal PythonQtWrapper_QVector4D::w(QVector4D* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->w()); | ||||
} | ||||
qreal PythonQtWrapper_QVector4D::x(QVector4D* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->x()); | ||||
} | ||||
qreal PythonQtWrapper_QVector4D::y(QVector4D* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->y()); | ||||
} | ||||
qreal PythonQtWrapper_QVector4D::z(QVector4D* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->z()); | ||||
} | ||||
QString PythonQtWrapper_QVector4D::py_toString(QVector4D* obj) { | ||||
QString result; | ||||
QDebug d(&result); | ||||
d << *obj; | ||||
return result; | ||||
} | ||||
QAction* PythonQtWrapper_QWhatsThis::static_QWhatsThis_createAction(QObject* parent) | ||||
{ | ||||
return (QWhatsThis::createAction(parent)); | ||||
} | ||||
void PythonQtWrapper_QWhatsThis::static_QWhatsThis_enterWhatsThisMode() | ||||
{ | ||||
(QWhatsThis::enterWhatsThisMode()); | ||||
} | ||||
void PythonQtWrapper_QWhatsThis::static_QWhatsThis_hideText() | ||||
{ | ||||
(QWhatsThis::hideText()); | ||||
} | ||||
bool PythonQtWrapper_QWhatsThis::static_QWhatsThis_inWhatsThisMode() | ||||
{ | ||||
return (QWhatsThis::inWhatsThisMode()); | ||||
} | ||||
void PythonQtWrapper_QWhatsThis::static_QWhatsThis_leaveWhatsThisMode() | ||||
{ | ||||
(QWhatsThis::leaveWhatsThisMode()); | ||||
} | ||||
void PythonQtWrapper_QWhatsThis::static_QWhatsThis_showText(const QPoint& pos, const QString& text, QWidget* w) | ||||
{ | ||||
(QWhatsThis::showText(pos, text, w)); | ||||
} | ||||
QWhatsThisClickedEvent* PythonQtWrapper_QWhatsThisClickedEvent::new_QWhatsThisClickedEvent(const QString& href) | ||||
{ | ||||
return new QWhatsThisClickedEvent(href); } | ||||
QString PythonQtWrapper_QWhatsThisClickedEvent::href(QWhatsThisClickedEvent* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->href()); | ||||
} | ||||
PythonQtShell_QWheelEvent::~PythonQtShell_QWheelEvent() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
QWheelEvent* PythonQtWrapper_QWheelEvent::new_QWheelEvent(const QPoint& pos, const QPoint& globalPos, int delta, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Qt::Orientation orient) | ||||
{ | ||||
return new PythonQtShell_QWheelEvent(pos, globalPos, delta, buttons, modifiers, orient); } | ||||
QWheelEvent* PythonQtWrapper_QWheelEvent::new_QWheelEvent(const QPoint& pos, int delta, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Qt::Orientation orient) | ||||
{ | ||||
return new PythonQtShell_QWheelEvent(pos, delta, buttons, modifiers, orient); } | ||||
Qt::MouseButtons PythonQtWrapper_QWheelEvent::buttons(QWheelEvent* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->buttons()); | ||||
} | ||||
int PythonQtWrapper_QWheelEvent::delta(QWheelEvent* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->delta()); | ||||
} | ||||
const QPoint* PythonQtWrapper_QWheelEvent::globalPos(QWheelEvent* theWrappedObject) const | ||||
{ | ||||
return &( theWrappedObject->globalPos()); | ||||
} | ||||
int PythonQtWrapper_QWheelEvent::globalX(QWheelEvent* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->globalX()); | ||||
} | ||||
int PythonQtWrapper_QWheelEvent::globalY(QWheelEvent* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->globalY()); | ||||
} | ||||
Qt::Orientation PythonQtWrapper_QWheelEvent::orientation(QWheelEvent* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->orientation()); | ||||
} | ||||
const QPoint* PythonQtWrapper_QWheelEvent::pos(QWheelEvent* theWrappedObject) const | ||||
{ | ||||
return &( theWrappedObject->pos()); | ||||
} | ||||
int PythonQtWrapper_QWheelEvent::x(QWheelEvent* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->x()); | ||||
} | ||||
int PythonQtWrapper_QWheelEvent::y(QWheelEvent* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->y()); | ||||
} | ||||
PythonQtShell_QWidget::~PythonQtShell_QWidget() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_QWidget::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; | ||||
} | ||||
} | ||||
QWidget::actionEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWidget::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; | ||||
} | ||||
} | ||||
QWidget::changeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWidget::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; | ||||
} | ||||
} | ||||
QWidget::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWidget::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; | ||||
} | ||||
} | ||||
QWidget::closeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWidget::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; | ||||
} | ||||
} | ||||
QWidget::contextMenuEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWidget::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; | ||||
} | ||||
} | ||||
QWidget::customEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QWidget::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 QWidget::devType(); | ||||
} | ||||
void PythonQtShell_QWidget::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; | ||||
} | ||||
} | ||||
QWidget::dragEnterEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWidget::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; | ||||
} | ||||
} | ||||
QWidget::dragLeaveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWidget::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; | ||||
} | ||||
} | ||||
QWidget::dragMoveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWidget::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; | ||||
} | ||||
} | ||||
QWidget::dropEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWidget::enabledChange(bool arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "enabledChange"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "bool"}; | ||||
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; | ||||
} | ||||
} | ||||
QWidget::enabledChange(arg__1); | ||||
} | ||||
void PythonQtShell_QWidget::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; | ||||
} | ||||
} | ||||
QWidget::enterEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QWidget::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 QWidget::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QWidget::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 QWidget::eventFilter(arg__1, arg__2); | ||||
} | ||||
void PythonQtShell_QWidget::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; | ||||
} | ||||
} | ||||
QWidget::focusInEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QWidget::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 QWidget::focusNextPrevChild(next); | ||||
} | ||||
void PythonQtShell_QWidget::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; | ||||
} | ||||
} | ||||
QWidget::focusOutEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWidget::fontChange(const QFont& arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "fontChange"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "const QFont&"}; | ||||
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; | ||||
} | ||||
} | ||||
QWidget::fontChange(arg__1); | ||||
} | ||||
int PythonQtShell_QWidget::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 QWidget::heightForWidth(arg__1); | ||||
} | ||||
void PythonQtShell_QWidget::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; | ||||
} | ||||
} | ||||
QWidget::hideEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWidget::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; | ||||
} | ||||
} | ||||
QWidget::inputMethodEvent(arg__1); | ||||
} | ||||
QVariant PythonQtShell_QWidget::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 QWidget::inputMethodQuery(arg__1); | ||||
} | ||||
void PythonQtShell_QWidget::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; | ||||
} | ||||
} | ||||
QWidget::keyPressEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWidget::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; | ||||
} | ||||
} | ||||
QWidget::keyReleaseEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWidget::languageChange() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "languageChange"); | ||||
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; | ||||
} | ||||
} | ||||
QWidget::languageChange(); | ||||
} | ||||
void PythonQtShell_QWidget::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; | ||||
} | ||||
} | ||||
QWidget::leaveEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QWidget::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 QWidget::metric(arg__1); | ||||
} | ||||
QSize PythonQtShell_QWidget::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 QWidget::minimumSizeHint(); | ||||
} | ||||
void PythonQtShell_QWidget::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; | ||||
} | ||||
} | ||||
QWidget::mouseDoubleClickEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWidget::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; | ||||
} | ||||
} | ||||
QWidget::mouseMoveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWidget::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; | ||||
} | ||||
} | ||||
QWidget::mousePressEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWidget::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; | ||||
} | ||||
} | ||||
QWidget::mouseReleaseEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWidget::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; | ||||
} | ||||
} | ||||
QWidget::moveEvent(arg__1); | ||||
} | ||||
QPaintEngine* PythonQtShell_QWidget::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 QWidget::paintEngine(); | ||||
} | ||||
void PythonQtShell_QWidget::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; | ||||
} | ||||
} | ||||
QWidget::paintEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWidget::paletteChange(const QPalette& arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "paletteChange"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "const QPalette&"}; | ||||
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; | ||||
} | ||||
} | ||||
QWidget::paletteChange(arg__1); | ||||
} | ||||
void PythonQtShell_QWidget::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; | ||||
} | ||||
} | ||||
QWidget::resizeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWidget::setVisible(bool visible) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setVisible"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&visible}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QWidget::setVisible(visible); | ||||
} | ||||
void PythonQtShell_QWidget::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; | ||||
} | ||||
} | ||||
QWidget::showEvent(arg__1); | ||||
} | ||||
QSize PythonQtShell_QWidget::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 QWidget::sizeHint(); | ||||
} | ||||
void PythonQtShell_QWidget::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; | ||||
} | ||||
} | ||||
QWidget::tabletEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWidget::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; | ||||
} | ||||
} | ||||
QWidget::timerEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWidget::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; | ||||
} | ||||
} | ||||
QWidget::wheelEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWidget::windowActivationChange(bool arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "windowActivationChange"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "bool"}; | ||||
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; | ||||
} | ||||
} | ||||
QWidget::windowActivationChange(arg__1); | ||||
} | ||||
QWidget* PythonQtWrapper_QWidget::new_QWidget(QWidget* parent, Qt::WindowFlags f) | ||||
{ | ||||
return new PythonQtShell_QWidget(parent, f); } | ||||
bool PythonQtWrapper_QWidget::acceptDrops(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->acceptDrops()); | ||||
} | ||||
QString PythonQtWrapper_QWidget::accessibleDescription(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->accessibleDescription()); | ||||
} | ||||
QString PythonQtWrapper_QWidget::accessibleName(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->accessibleName()); | ||||
} | ||||
void PythonQtWrapper_QWidget::actionEvent(QWidget* theWrappedObject, QActionEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWidget*)theWrappedObject)->promoted_actionEvent(arg__1)); | ||||
} | ||||
QList<QAction* > PythonQtWrapper_QWidget::actions(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->actions()); | ||||
} | ||||
void PythonQtWrapper_QWidget::activateWindow(QWidget* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->activateWindow()); | ||||
} | ||||
void PythonQtWrapper_QWidget::addAction(QWidget* theWrappedObject, QAction* action) | ||||
{ | ||||
( theWrappedObject->addAction(action)); | ||||
} | ||||
void PythonQtWrapper_QWidget::addActions(QWidget* theWrappedObject, QList<QAction* > actions) | ||||
{ | ||||
( theWrappedObject->addActions(actions)); | ||||
} | ||||
void PythonQtWrapper_QWidget::adjustSize(QWidget* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->adjustSize()); | ||||
} | ||||
bool PythonQtWrapper_QWidget::autoFillBackground(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->autoFillBackground()); | ||||
} | ||||
QPalette::ColorRole PythonQtWrapper_QWidget::backgroundRole(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->backgroundRole()); | ||||
} | ||||
QSize PythonQtWrapper_QWidget::baseSize(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->baseSize()); | ||||
} | ||||
void PythonQtWrapper_QWidget::changeEvent(QWidget* theWrappedObject, QEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWidget*)theWrappedObject)->promoted_changeEvent(arg__1)); | ||||
} | ||||
QWidget* PythonQtWrapper_QWidget::childAt(QWidget* theWrappedObject, const QPoint& p) const | ||||
{ | ||||
return ( theWrappedObject->childAt(p)); | ||||
} | ||||
QWidget* PythonQtWrapper_QWidget::childAt(QWidget* theWrappedObject, int x, int y) const | ||||
{ | ||||
return ( theWrappedObject->childAt(x, y)); | ||||
} | ||||
QRect PythonQtWrapper_QWidget::childrenRect(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->childrenRect()); | ||||
} | ||||
QRegion PythonQtWrapper_QWidget::childrenRegion(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->childrenRegion()); | ||||
} | ||||
void PythonQtWrapper_QWidget::clearFocus(QWidget* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->clearFocus()); | ||||
} | ||||
void PythonQtWrapper_QWidget::clearMask(QWidget* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->clearMask()); | ||||
} | ||||
void PythonQtWrapper_QWidget::closeEvent(QWidget* theWrappedObject, QCloseEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWidget*)theWrappedObject)->promoted_closeEvent(arg__1)); | ||||
} | ||||
QMargins PythonQtWrapper_QWidget::contentsMargins(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->contentsMargins()); | ||||
} | ||||
QRect PythonQtWrapper_QWidget::contentsRect(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->contentsRect()); | ||||
} | ||||
void PythonQtWrapper_QWidget::contextMenuEvent(QWidget* theWrappedObject, QContextMenuEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWidget*)theWrappedObject)->promoted_contextMenuEvent(arg__1)); | ||||
} | ||||
Qt::ContextMenuPolicy PythonQtWrapper_QWidget::contextMenuPolicy(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->contextMenuPolicy()); | ||||
} | ||||
void PythonQtWrapper_QWidget::createWinId(QWidget* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->createWinId()); | ||||
} | ||||
QCursor PythonQtWrapper_QWidget::cursor(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->cursor()); | ||||
} | ||||
int PythonQtWrapper_QWidget::devType(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QWidget*)theWrappedObject)->promoted_devType()); | ||||
} | ||||
void PythonQtWrapper_QWidget::dragEnterEvent(QWidget* theWrappedObject, QDragEnterEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWidget*)theWrappedObject)->promoted_dragEnterEvent(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWidget::dragLeaveEvent(QWidget* theWrappedObject, QDragLeaveEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWidget*)theWrappedObject)->promoted_dragLeaveEvent(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWidget::dragMoveEvent(QWidget* theWrappedObject, QDragMoveEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWidget*)theWrappedObject)->promoted_dragMoveEvent(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWidget::dropEvent(QWidget* theWrappedObject, QDropEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWidget*)theWrappedObject)->promoted_dropEvent(arg__1)); | ||||
} | ||||
WId PythonQtWrapper_QWidget::effectiveWinId(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->effectiveWinId()); | ||||
} | ||||
void PythonQtWrapper_QWidget::ensurePolished(QWidget* theWrappedObject) const | ||||
{ | ||||
( theWrappedObject->ensurePolished()); | ||||
} | ||||
void PythonQtWrapper_QWidget::enterEvent(QWidget* theWrappedObject, QEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWidget*)theWrappedObject)->promoted_enterEvent(arg__1)); | ||||
} | ||||
bool PythonQtWrapper_QWidget::event(QWidget* theWrappedObject, QEvent* arg__1) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QWidget*)theWrappedObject)->promoted_event(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWidget::focusInEvent(QWidget* theWrappedObject, QFocusEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWidget*)theWrappedObject)->promoted_focusInEvent(arg__1)); | ||||
} | ||||
bool PythonQtWrapper_QWidget::focusNextPrevChild(QWidget* theWrappedObject, bool next) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QWidget*)theWrappedObject)->promoted_focusNextPrevChild(next)); | ||||
} | ||||
void PythonQtWrapper_QWidget::focusOutEvent(QWidget* theWrappedObject, QFocusEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWidget*)theWrappedObject)->promoted_focusOutEvent(arg__1)); | ||||
} | ||||
Qt::FocusPolicy PythonQtWrapper_QWidget::focusPolicy(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->focusPolicy()); | ||||
} | ||||
QWidget* PythonQtWrapper_QWidget::focusProxy(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->focusProxy()); | ||||
} | ||||
QWidget* PythonQtWrapper_QWidget::focusWidget(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->focusWidget()); | ||||
} | ||||
const QFont* PythonQtWrapper_QWidget::font(QWidget* theWrappedObject) const | ||||
{ | ||||
return &( theWrappedObject->font()); | ||||
} | ||||
QPalette::ColorRole PythonQtWrapper_QWidget::foregroundRole(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->foregroundRole()); | ||||
} | ||||
QRect PythonQtWrapper_QWidget::frameGeometry(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->frameGeometry()); | ||||
} | ||||
QSize PythonQtWrapper_QWidget::frameSize(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->frameSize()); | ||||
} | ||||
const QRect* PythonQtWrapper_QWidget::geometry(QWidget* theWrappedObject) const | ||||
{ | ||||
return &( theWrappedObject->geometry()); | ||||
} | ||||
void PythonQtWrapper_QWidget::getContentsMargins(QWidget* theWrappedObject, int* left, int* top, int* right, int* bottom) const | ||||
{ | ||||
( theWrappedObject->getContentsMargins(left, top, right, bottom)); | ||||
} | ||||
void PythonQtWrapper_QWidget::grabGesture(QWidget* theWrappedObject, Qt::GestureType type, Qt::GestureFlags flags) | ||||
{ | ||||
( theWrappedObject->grabGesture(type, flags)); | ||||
} | ||||
void PythonQtWrapper_QWidget::grabKeyboard(QWidget* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->grabKeyboard()); | ||||
} | ||||
void PythonQtWrapper_QWidget::grabMouse(QWidget* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->grabMouse()); | ||||
} | ||||
void PythonQtWrapper_QWidget::grabMouse(QWidget* theWrappedObject, const QCursor& arg__1) | ||||
{ | ||||
( theWrappedObject->grabMouse(arg__1)); | ||||
} | ||||
int PythonQtWrapper_QWidget::grabShortcut(QWidget* theWrappedObject, const QKeySequence& key, Qt::ShortcutContext context) | ||||
{ | ||||
return ( theWrappedObject->grabShortcut(key, context)); | ||||
} | ||||
QGraphicsEffect* PythonQtWrapper_QWidget::graphicsEffect(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->graphicsEffect()); | ||||
} | ||||
QGraphicsProxyWidget* PythonQtWrapper_QWidget::graphicsProxyWidget(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->graphicsProxyWidget()); | ||||
} | ||||
bool PythonQtWrapper_QWidget::hasFocus(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->hasFocus()); | ||||
} | ||||
bool PythonQtWrapper_QWidget::hasMouseTracking(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->hasMouseTracking()); | ||||
} | ||||
int PythonQtWrapper_QWidget::height(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->height()); | ||||
} | ||||
int PythonQtWrapper_QWidget::heightForWidth(QWidget* theWrappedObject, int arg__1) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QWidget*)theWrappedObject)->promoted_heightForWidth(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWidget::hideEvent(QWidget* theWrappedObject, QHideEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWidget*)theWrappedObject)->promoted_hideEvent(arg__1)); | ||||
} | ||||
QInputContext* PythonQtWrapper_QWidget::inputContext(QWidget* theWrappedObject) | ||||
{ | ||||
return ( theWrappedObject->inputContext()); | ||||
} | ||||
void PythonQtWrapper_QWidget::inputMethodEvent(QWidget* theWrappedObject, QInputMethodEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWidget*)theWrappedObject)->promoted_inputMethodEvent(arg__1)); | ||||
} | ||||
Qt::InputMethodHints PythonQtWrapper_QWidget::inputMethodHints(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->inputMethodHints()); | ||||
} | ||||
QVariant PythonQtWrapper_QWidget::inputMethodQuery(QWidget* theWrappedObject, Qt::InputMethodQuery arg__1) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QWidget*)theWrappedObject)->promoted_inputMethodQuery(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWidget::insertAction(QWidget* theWrappedObject, QAction* before, QAction* action) | ||||
{ | ||||
( theWrappedObject->insertAction(before, action)); | ||||
} | ||||
void PythonQtWrapper_QWidget::insertActions(QWidget* theWrappedObject, QAction* before, QList<QAction* > actions) | ||||
{ | ||||
( theWrappedObject->insertActions(before, actions)); | ||||
} | ||||
bool PythonQtWrapper_QWidget::isActiveWindow(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isActiveWindow()); | ||||
} | ||||
bool PythonQtWrapper_QWidget::isAncestorOf(QWidget* theWrappedObject, const QWidget* child) const | ||||
{ | ||||
return ( theWrappedObject->isAncestorOf(child)); | ||||
} | ||||
bool PythonQtWrapper_QWidget::isEnabled(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isEnabled()); | ||||
} | ||||
bool PythonQtWrapper_QWidget::isEnabledTo(QWidget* theWrappedObject, QWidget* arg__1) const | ||||
{ | ||||
return ( theWrappedObject->isEnabledTo(arg__1)); | ||||
} | ||||
bool PythonQtWrapper_QWidget::isFullScreen(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isFullScreen()); | ||||
} | ||||
bool PythonQtWrapper_QWidget::isHidden(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isHidden()); | ||||
} | ||||
bool PythonQtWrapper_QWidget::isLeftToRight(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isLeftToRight()); | ||||
} | ||||
bool PythonQtWrapper_QWidget::isMaximized(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isMaximized()); | ||||
} | ||||
bool PythonQtWrapper_QWidget::isMinimized(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isMinimized()); | ||||
} | ||||
bool PythonQtWrapper_QWidget::isModal(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isModal()); | ||||
} | ||||
bool PythonQtWrapper_QWidget::isRightToLeft(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isRightToLeft()); | ||||
} | ||||
bool PythonQtWrapper_QWidget::isVisible(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isVisible()); | ||||
} | ||||
bool PythonQtWrapper_QWidget::isVisibleTo(QWidget* theWrappedObject, QWidget* arg__1) const | ||||
{ | ||||
return ( theWrappedObject->isVisibleTo(arg__1)); | ||||
} | ||||
bool PythonQtWrapper_QWidget::isWindow(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isWindow()); | ||||
} | ||||
bool PythonQtWrapper_QWidget::isWindowModified(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isWindowModified()); | ||||
} | ||||
void PythonQtWrapper_QWidget::keyPressEvent(QWidget* theWrappedObject, QKeyEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWidget*)theWrappedObject)->promoted_keyPressEvent(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWidget::keyReleaseEvent(QWidget* theWrappedObject, QKeyEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWidget*)theWrappedObject)->promoted_keyReleaseEvent(arg__1)); | ||||
} | ||||
QWidget* PythonQtWrapper_QWidget::static_QWidget_keyboardGrabber() | ||||
{ | ||||
return (QWidget::keyboardGrabber()); | ||||
} | ||||
void PythonQtWrapper_QWidget::languageChange(QWidget* theWrappedObject) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWidget*)theWrappedObject)->promoted_languageChange()); | ||||
} | ||||
QLayout* PythonQtWrapper_QWidget::layout(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->layout()); | ||||
} | ||||
Qt::LayoutDirection PythonQtWrapper_QWidget::layoutDirection(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->layoutDirection()); | ||||
} | ||||
void PythonQtWrapper_QWidget::leaveEvent(QWidget* theWrappedObject, QEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWidget*)theWrappedObject)->promoted_leaveEvent(arg__1)); | ||||
} | ||||
QLocale PythonQtWrapper_QWidget::locale(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->locale()); | ||||
} | ||||
QPoint PythonQtWrapper_QWidget::mapFrom(QWidget* theWrappedObject, QWidget* arg__1, const QPoint& arg__2) const | ||||
{ | ||||
return ( theWrappedObject->mapFrom(arg__1, arg__2)); | ||||
} | ||||
QPoint PythonQtWrapper_QWidget::mapFromGlobal(QWidget* theWrappedObject, const QPoint& arg__1) const | ||||
{ | ||||
return ( theWrappedObject->mapFromGlobal(arg__1)); | ||||
} | ||||
QPoint PythonQtWrapper_QWidget::mapFromParent(QWidget* theWrappedObject, const QPoint& arg__1) const | ||||
{ | ||||
return ( theWrappedObject->mapFromParent(arg__1)); | ||||
} | ||||
QPoint PythonQtWrapper_QWidget::mapTo(QWidget* theWrappedObject, QWidget* arg__1, const QPoint& arg__2) const | ||||
{ | ||||
return ( theWrappedObject->mapTo(arg__1, arg__2)); | ||||
} | ||||
QPoint PythonQtWrapper_QWidget::mapToGlobal(QWidget* theWrappedObject, const QPoint& arg__1) const | ||||
{ | ||||
return ( theWrappedObject->mapToGlobal(arg__1)); | ||||
} | ||||
QPoint PythonQtWrapper_QWidget::mapToParent(QWidget* theWrappedObject, const QPoint& arg__1) const | ||||
{ | ||||
return ( theWrappedObject->mapToParent(arg__1)); | ||||
} | ||||
QRegion PythonQtWrapper_QWidget::mask(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->mask()); | ||||
} | ||||
int PythonQtWrapper_QWidget::maximumHeight(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->maximumHeight()); | ||||
} | ||||
QSize PythonQtWrapper_QWidget::maximumSize(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->maximumSize()); | ||||
} | ||||
int PythonQtWrapper_QWidget::maximumWidth(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->maximumWidth()); | ||||
} | ||||
int PythonQtWrapper_QWidget::metric(QWidget* theWrappedObject, QPaintDevice::PaintDeviceMetric arg__1) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QWidget*)theWrappedObject)->promoted_metric(arg__1)); | ||||
} | ||||
int PythonQtWrapper_QWidget::minimumHeight(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->minimumHeight()); | ||||
} | ||||
QSize PythonQtWrapper_QWidget::minimumSize(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->minimumSize()); | ||||
} | ||||
QSize PythonQtWrapper_QWidget::minimumSizeHint(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QWidget*)theWrappedObject)->promoted_minimumSizeHint()); | ||||
} | ||||
int PythonQtWrapper_QWidget::minimumWidth(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->minimumWidth()); | ||||
} | ||||
void PythonQtWrapper_QWidget::mouseDoubleClickEvent(QWidget* theWrappedObject, QMouseEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWidget*)theWrappedObject)->promoted_mouseDoubleClickEvent(arg__1)); | ||||
} | ||||
QWidget* PythonQtWrapper_QWidget::static_QWidget_mouseGrabber() | ||||
{ | ||||
return (QWidget::mouseGrabber()); | ||||
} | ||||
void PythonQtWrapper_QWidget::mouseMoveEvent(QWidget* theWrappedObject, QMouseEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWidget*)theWrappedObject)->promoted_mouseMoveEvent(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWidget::mousePressEvent(QWidget* theWrappedObject, QMouseEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWidget*)theWrappedObject)->promoted_mousePressEvent(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWidget::mouseReleaseEvent(QWidget* theWrappedObject, QMouseEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWidget*)theWrappedObject)->promoted_mouseReleaseEvent(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWidget::move(QWidget* theWrappedObject, const QPoint& arg__1) | ||||
{ | ||||
( theWrappedObject->move(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWidget::move(QWidget* theWrappedObject, int x, int y) | ||||
{ | ||||
( theWrappedObject->move(x, y)); | ||||
} | ||||
void PythonQtWrapper_QWidget::moveEvent(QWidget* theWrappedObject, QMoveEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWidget*)theWrappedObject)->promoted_moveEvent(arg__1)); | ||||
} | ||||
QWidget* PythonQtWrapper_QWidget::nativeParentWidget(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->nativeParentWidget()); | ||||
} | ||||
QWidget* PythonQtWrapper_QWidget::nextInFocusChain(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->nextInFocusChain()); | ||||
} | ||||
QRect PythonQtWrapper_QWidget::normalGeometry(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->normalGeometry()); | ||||
} | ||||
void PythonQtWrapper_QWidget::overrideWindowFlags(QWidget* theWrappedObject, Qt::WindowFlags type) | ||||
{ | ||||
( theWrappedObject->overrideWindowFlags(type)); | ||||
} | ||||
void PythonQtWrapper_QWidget::overrideWindowState(QWidget* theWrappedObject, Qt::WindowStates state) | ||||
{ | ||||
( theWrappedObject->overrideWindowState(state)); | ||||
} | ||||
QPaintEngine* PythonQtWrapper_QWidget::paintEngine(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QWidget*)theWrappedObject)->promoted_paintEngine()); | ||||
} | ||||
void PythonQtWrapper_QWidget::paintEvent(QWidget* theWrappedObject, QPaintEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWidget*)theWrappedObject)->promoted_paintEvent(arg__1)); | ||||
} | ||||
const QPalette* PythonQtWrapper_QWidget::palette(QWidget* theWrappedObject) const | ||||
{ | ||||
return &( theWrappedObject->palette()); | ||||
} | ||||
QWidget* PythonQtWrapper_QWidget::parentWidget(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->parentWidget()); | ||||
} | ||||
QPoint PythonQtWrapper_QWidget::pos(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->pos()); | ||||
} | ||||
QWidget* PythonQtWrapper_QWidget::previousInFocusChain(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->previousInFocusChain()); | ||||
} | ||||
QRect PythonQtWrapper_QWidget::rect(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->rect()); | ||||
} | ||||
void PythonQtWrapper_QWidget::releaseKeyboard(QWidget* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->releaseKeyboard()); | ||||
} | ||||
void PythonQtWrapper_QWidget::releaseMouse(QWidget* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->releaseMouse()); | ||||
} | ||||
void PythonQtWrapper_QWidget::releaseShortcut(QWidget* theWrappedObject, int id) | ||||
{ | ||||
( theWrappedObject->releaseShortcut(id)); | ||||
} | ||||
void PythonQtWrapper_QWidget::removeAction(QWidget* theWrappedObject, QAction* action) | ||||
{ | ||||
( theWrappedObject->removeAction(action)); | ||||
} | ||||
void PythonQtWrapper_QWidget::render(QWidget* theWrappedObject, QPaintDevice* target, const QPoint& targetOffset, const QRegion& sourceRegion, QWidget::RenderFlags renderFlags) | ||||
{ | ||||
( theWrappedObject->render(target, targetOffset, sourceRegion, renderFlags)); | ||||
} | ||||
void PythonQtWrapper_QWidget::render(QWidget* theWrappedObject, QPainter* painter, const QPoint& targetOffset, const QRegion& sourceRegion, QWidget::RenderFlags renderFlags) | ||||
{ | ||||
( theWrappedObject->render(painter, targetOffset, sourceRegion, renderFlags)); | ||||
} | ||||
void PythonQtWrapper_QWidget::repaint(QWidget* theWrappedObject, const QRect& arg__1) | ||||
{ | ||||
( theWrappedObject->repaint(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWidget::repaint(QWidget* theWrappedObject, const QRegion& arg__1) | ||||
{ | ||||
( theWrappedObject->repaint(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWidget::repaint(QWidget* theWrappedObject, int x, int y, int w, int h) | ||||
{ | ||||
( theWrappedObject->repaint(x, y, w, h)); | ||||
} | ||||
void PythonQtWrapper_QWidget::resize(QWidget* theWrappedObject, const QSize& arg__1) | ||||
{ | ||||
( theWrappedObject->resize(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWidget::resize(QWidget* theWrappedObject, int w, int h) | ||||
{ | ||||
( theWrappedObject->resize(w, h)); | ||||
} | ||||
void PythonQtWrapper_QWidget::resizeEvent(QWidget* theWrappedObject, QResizeEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWidget*)theWrappedObject)->promoted_resizeEvent(arg__1)); | ||||
} | ||||
bool PythonQtWrapper_QWidget::restoreGeometry(QWidget* theWrappedObject, const QByteArray& geometry) | ||||
{ | ||||
return ( theWrappedObject->restoreGeometry(geometry)); | ||||
} | ||||
QByteArray PythonQtWrapper_QWidget::saveGeometry(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->saveGeometry()); | ||||
} | ||||
void PythonQtWrapper_QWidget::scroll(QWidget* theWrappedObject, int dx, int dy) | ||||
{ | ||||
( theWrappedObject->scroll(dx, dy)); | ||||
} | ||||
void PythonQtWrapper_QWidget::scroll(QWidget* theWrappedObject, int dx, int dy, const QRect& arg__3) | ||||
{ | ||||
( theWrappedObject->scroll(dx, dy, arg__3)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setAcceptDrops(QWidget* theWrappedObject, bool on) | ||||
{ | ||||
( theWrappedObject->setAcceptDrops(on)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setAccessibleDescription(QWidget* theWrappedObject, const QString& description) | ||||
{ | ||||
( theWrappedObject->setAccessibleDescription(description)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setAccessibleName(QWidget* theWrappedObject, const QString& name) | ||||
{ | ||||
( theWrappedObject->setAccessibleName(name)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setAttribute(QWidget* theWrappedObject, Qt::WidgetAttribute arg__1, bool on) | ||||
{ | ||||
( theWrappedObject->setAttribute(arg__1, on)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setAutoFillBackground(QWidget* theWrappedObject, bool enabled) | ||||
{ | ||||
( theWrappedObject->setAutoFillBackground(enabled)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setBackgroundRole(QWidget* theWrappedObject, QPalette::ColorRole arg__1) | ||||
{ | ||||
( theWrappedObject->setBackgroundRole(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setBaseSize(QWidget* theWrappedObject, const QSize& arg__1) | ||||
{ | ||||
( theWrappedObject->setBaseSize(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setBaseSize(QWidget* theWrappedObject, int basew, int baseh) | ||||
{ | ||||
( theWrappedObject->setBaseSize(basew, baseh)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setContentsMargins(QWidget* theWrappedObject, const QMargins& margins) | ||||
{ | ||||
( theWrappedObject->setContentsMargins(margins)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setContentsMargins(QWidget* theWrappedObject, int left, int top, int right, int bottom) | ||||
{ | ||||
( theWrappedObject->setContentsMargins(left, top, right, bottom)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setContextMenuPolicy(QWidget* theWrappedObject, Qt::ContextMenuPolicy policy) | ||||
{ | ||||
( theWrappedObject->setContextMenuPolicy(policy)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setCursor(QWidget* theWrappedObject, const QCursor& arg__1) | ||||
{ | ||||
( theWrappedObject->setCursor(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setFixedHeight(QWidget* theWrappedObject, int h) | ||||
{ | ||||
( theWrappedObject->setFixedHeight(h)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setFixedSize(QWidget* theWrappedObject, const QSize& arg__1) | ||||
{ | ||||
( theWrappedObject->setFixedSize(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setFixedSize(QWidget* theWrappedObject, int w, int h) | ||||
{ | ||||
( theWrappedObject->setFixedSize(w, h)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setFixedWidth(QWidget* theWrappedObject, int w) | ||||
{ | ||||
( theWrappedObject->setFixedWidth(w)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setFocus(QWidget* theWrappedObject, Qt::FocusReason reason) | ||||
{ | ||||
( theWrappedObject->setFocus(reason)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setFocusPolicy(QWidget* theWrappedObject, Qt::FocusPolicy policy) | ||||
{ | ||||
( theWrappedObject->setFocusPolicy(policy)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setFocusProxy(QWidget* theWrappedObject, QWidget* arg__1) | ||||
{ | ||||
( theWrappedObject->setFocusProxy(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setFont(QWidget* theWrappedObject, const QFont& arg__1) | ||||
{ | ||||
( theWrappedObject->setFont(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setForegroundRole(QWidget* theWrappedObject, QPalette::ColorRole arg__1) | ||||
{ | ||||
( theWrappedObject->setForegroundRole(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setGeometry(QWidget* theWrappedObject, const QRect& arg__1) | ||||
{ | ||||
( theWrappedObject->setGeometry(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setGeometry(QWidget* theWrappedObject, int x, int y, int w, int h) | ||||
{ | ||||
( theWrappedObject->setGeometry(x, y, w, h)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setGraphicsEffect(QWidget* theWrappedObject, QGraphicsEffect* effect) | ||||
{ | ||||
( theWrappedObject->setGraphicsEffect(effect)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setInputContext(QWidget* theWrappedObject, QInputContext* arg__1) | ||||
{ | ||||
( theWrappedObject->setInputContext(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setInputMethodHints(QWidget* theWrappedObject, Qt::InputMethodHints hints) | ||||
{ | ||||
( theWrappedObject->setInputMethodHints(hints)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setLayout(QWidget* theWrappedObject, QLayout* arg__1) | ||||
{ | ||||
( theWrappedObject->setLayout(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setLayoutDirection(QWidget* theWrappedObject, Qt::LayoutDirection direction) | ||||
{ | ||||
( theWrappedObject->setLayoutDirection(direction)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setLocale(QWidget* theWrappedObject, const QLocale& locale) | ||||
{ | ||||
( theWrappedObject->setLocale(locale)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setMask(QWidget* theWrappedObject, const QBitmap& arg__1) | ||||
{ | ||||
( theWrappedObject->setMask(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setMask(QWidget* theWrappedObject, const QRegion& arg__1) | ||||
{ | ||||
( theWrappedObject->setMask(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setMaximumHeight(QWidget* theWrappedObject, int maxh) | ||||
{ | ||||
( theWrappedObject->setMaximumHeight(maxh)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setMaximumSize(QWidget* theWrappedObject, const QSize& arg__1) | ||||
{ | ||||
( theWrappedObject->setMaximumSize(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setMaximumSize(QWidget* theWrappedObject, int maxw, int maxh) | ||||
{ | ||||
( theWrappedObject->setMaximumSize(maxw, maxh)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setMaximumWidth(QWidget* theWrappedObject, int maxw) | ||||
{ | ||||
( theWrappedObject->setMaximumWidth(maxw)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setMinimumHeight(QWidget* theWrappedObject, int minh) | ||||
{ | ||||
( theWrappedObject->setMinimumHeight(minh)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setMinimumSize(QWidget* theWrappedObject, const QSize& arg__1) | ||||
{ | ||||
( theWrappedObject->setMinimumSize(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setMinimumSize(QWidget* theWrappedObject, int minw, int minh) | ||||
{ | ||||
( theWrappedObject->setMinimumSize(minw, minh)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setMinimumWidth(QWidget* theWrappedObject, int minw) | ||||
{ | ||||
( theWrappedObject->setMinimumWidth(minw)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setMouseTracking(QWidget* theWrappedObject, bool enable) | ||||
{ | ||||
( theWrappedObject->setMouseTracking(enable)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setPalette(QWidget* theWrappedObject, const QPalette& arg__1) | ||||
{ | ||||
( theWrappedObject->setPalette(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setParent(QWidget* theWrappedObject, QWidget* parent) | ||||
{ | ||||
( theWrappedObject->setParent(parent)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setParent(QWidget* theWrappedObject, QWidget* parent, Qt::WindowFlags f) | ||||
{ | ||||
( theWrappedObject->setParent(parent, f)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setShortcutAutoRepeat(QWidget* theWrappedObject, int id, bool enable) | ||||
{ | ||||
( theWrappedObject->setShortcutAutoRepeat(id, enable)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setShortcutEnabled(QWidget* theWrappedObject, int id, bool enable) | ||||
{ | ||||
( theWrappedObject->setShortcutEnabled(id, enable)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setSizeIncrement(QWidget* theWrappedObject, const QSize& arg__1) | ||||
{ | ||||
( theWrappedObject->setSizeIncrement(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setSizeIncrement(QWidget* theWrappedObject, int w, int h) | ||||
{ | ||||
( theWrappedObject->setSizeIncrement(w, h)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setSizePolicy(QWidget* theWrappedObject, QSizePolicy arg__1) | ||||
{ | ||||
( theWrappedObject->setSizePolicy(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setSizePolicy(QWidget* theWrappedObject, QSizePolicy::Policy horizontal, QSizePolicy::Policy vertical) | ||||
{ | ||||
( theWrappedObject->setSizePolicy(horizontal, vertical)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setStatusTip(QWidget* theWrappedObject, const QString& arg__1) | ||||
{ | ||||
( theWrappedObject->setStatusTip(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setStyle(QWidget* theWrappedObject, QStyle* arg__1) | ||||
{ | ||||
( theWrappedObject->setStyle(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWidget::static_QWidget_setTabOrder(QWidget* arg__1, QWidget* arg__2) | ||||
{ | ||||
(QWidget::setTabOrder(arg__1, arg__2)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setToolTip(QWidget* theWrappedObject, const QString& arg__1) | ||||
{ | ||||
( theWrappedObject->setToolTip(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setUpdatesEnabled(QWidget* theWrappedObject, bool enable) | ||||
{ | ||||
( theWrappedObject->setUpdatesEnabled(enable)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setWhatsThis(QWidget* theWrappedObject, const QString& arg__1) | ||||
{ | ||||
( theWrappedObject->setWhatsThis(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setWindowFilePath(QWidget* theWrappedObject, const QString& filePath) | ||||
{ | ||||
( theWrappedObject->setWindowFilePath(filePath)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setWindowFlags(QWidget* theWrappedObject, Qt::WindowFlags type) | ||||
{ | ||||
( theWrappedObject->setWindowFlags(type)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setWindowIcon(QWidget* theWrappedObject, const QIcon& icon) | ||||
{ | ||||
( theWrappedObject->setWindowIcon(icon)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setWindowIconText(QWidget* theWrappedObject, const QString& arg__1) | ||||
{ | ||||
( theWrappedObject->setWindowIconText(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setWindowModality(QWidget* theWrappedObject, Qt::WindowModality windowModality) | ||||
{ | ||||
( theWrappedObject->setWindowModality(windowModality)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setWindowOpacity(QWidget* theWrappedObject, qreal level) | ||||
{ | ||||
( theWrappedObject->setWindowOpacity(level)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setWindowRole(QWidget* theWrappedObject, const QString& arg__1) | ||||
{ | ||||
( theWrappedObject->setWindowRole(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWidget::setWindowState(QWidget* theWrappedObject, Qt::WindowStates state) | ||||
{ | ||||
( theWrappedObject->setWindowState(state)); | ||||
} | ||||
void PythonQtWrapper_QWidget::showEvent(QWidget* theWrappedObject, QShowEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWidget*)theWrappedObject)->promoted_showEvent(arg__1)); | ||||
} | ||||
QSize PythonQtWrapper_QWidget::size(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->size()); | ||||
} | ||||
QSize PythonQtWrapper_QWidget::sizeHint(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QWidget*)theWrappedObject)->promoted_sizeHint()); | ||||
} | ||||
QSize PythonQtWrapper_QWidget::sizeIncrement(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->sizeIncrement()); | ||||
} | ||||
QSizePolicy PythonQtWrapper_QWidget::sizePolicy(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->sizePolicy()); | ||||
} | ||||
void PythonQtWrapper_QWidget::stackUnder(QWidget* theWrappedObject, QWidget* arg__1) | ||||
{ | ||||
( theWrappedObject->stackUnder(arg__1)); | ||||
} | ||||
QString PythonQtWrapper_QWidget::statusTip(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->statusTip()); | ||||
} | ||||
QStyle* PythonQtWrapper_QWidget::style(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->style()); | ||||
} | ||||
QString PythonQtWrapper_QWidget::styleSheet(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->styleSheet()); | ||||
} | ||||
void PythonQtWrapper_QWidget::tabletEvent(QWidget* theWrappedObject, QTabletEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWidget*)theWrappedObject)->promoted_tabletEvent(arg__1)); | ||||
} | ||||
bool PythonQtWrapper_QWidget::testAttribute(QWidget* theWrappedObject, Qt::WidgetAttribute arg__1) const | ||||
{ | ||||
return ( theWrappedObject->testAttribute(arg__1)); | ||||
} | ||||
QString PythonQtWrapper_QWidget::toolTip(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->toolTip()); | ||||
} | ||||
bool PythonQtWrapper_QWidget::underMouse(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->underMouse()); | ||||
} | ||||
void PythonQtWrapper_QWidget::ungrabGesture(QWidget* theWrappedObject, Qt::GestureType type) | ||||
{ | ||||
( theWrappedObject->ungrabGesture(type)); | ||||
} | ||||
void PythonQtWrapper_QWidget::unsetCursor(QWidget* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->unsetCursor()); | ||||
} | ||||
void PythonQtWrapper_QWidget::unsetLayoutDirection(QWidget* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->unsetLayoutDirection()); | ||||
} | ||||
void PythonQtWrapper_QWidget::unsetLocale(QWidget* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->unsetLocale()); | ||||
} | ||||
void PythonQtWrapper_QWidget::update(QWidget* theWrappedObject, const QRect& arg__1) | ||||
{ | ||||
( theWrappedObject->update(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWidget::update(QWidget* theWrappedObject, const QRegion& arg__1) | ||||
{ | ||||
( theWrappedObject->update(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWidget::update(QWidget* theWrappedObject, int x, int y, int w, int h) | ||||
{ | ||||
( theWrappedObject->update(x, y, w, h)); | ||||
} | ||||
void PythonQtWrapper_QWidget::updateGeometry(QWidget* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->updateGeometry()); | ||||
} | ||||
bool PythonQtWrapper_QWidget::updatesEnabled(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->updatesEnabled()); | ||||
} | ||||
QRegion PythonQtWrapper_QWidget::visibleRegion(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->visibleRegion()); | ||||
} | ||||
QString PythonQtWrapper_QWidget::whatsThis(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->whatsThis()); | ||||
} | ||||
void PythonQtWrapper_QWidget::wheelEvent(QWidget* theWrappedObject, QWheelEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWidget*)theWrappedObject)->promoted_wheelEvent(arg__1)); | ||||
} | ||||
int PythonQtWrapper_QWidget::width(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->width()); | ||||
} | ||||
WId PythonQtWrapper_QWidget::winId(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->winId()); | ||||
} | ||||
QWidget* PythonQtWrapper_QWidget::window(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->window()); | ||||
} | ||||
QString PythonQtWrapper_QWidget::windowFilePath(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->windowFilePath()); | ||||
} | ||||
Qt::WindowFlags PythonQtWrapper_QWidget::windowFlags(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->windowFlags()); | ||||
} | ||||
QIcon PythonQtWrapper_QWidget::windowIcon(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->windowIcon()); | ||||
} | ||||
QString PythonQtWrapper_QWidget::windowIconText(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->windowIconText()); | ||||
} | ||||
Qt::WindowModality PythonQtWrapper_QWidget::windowModality(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->windowModality()); | ||||
} | ||||
qreal PythonQtWrapper_QWidget::windowOpacity(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->windowOpacity()); | ||||
} | ||||
QString PythonQtWrapper_QWidget::windowRole(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->windowRole()); | ||||
} | ||||
Qt::WindowStates PythonQtWrapper_QWidget::windowState(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->windowState()); | ||||
} | ||||
QString PythonQtWrapper_QWidget::windowTitle(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->windowTitle()); | ||||
} | ||||
Qt::WindowType PythonQtWrapper_QWidget::windowType(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->windowType()); | ||||
} | ||||
int PythonQtWrapper_QWidget::x(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->x()); | ||||
} | ||||
int PythonQtWrapper_QWidget::y(QWidget* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->y()); | ||||
} | ||||
PythonQtShell_QWidgetAction::~PythonQtShell_QWidgetAction() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_QWidgetAction::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; | ||||
} | ||||
} | ||||
QWidgetAction::childEvent(arg__1); | ||||
} | ||||
QWidget* PythonQtShell_QWidgetAction::createWidget(QWidget* parent) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "createWidget"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QWidget*" , "QWidget*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QWidget* returnValue; | ||||
void* args[2] = {NULL, (void*)&parent}; | ||||
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("createWidget", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QWidget**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QWidgetAction::createWidget(parent); | ||||
} | ||||
void PythonQtShell_QWidgetAction::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; | ||||
} | ||||
} | ||||
QWidgetAction::customEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWidgetAction::deleteWidget(QWidget* widget) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "deleteWidget"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QWidget*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&widget}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QWidgetAction::deleteWidget(widget); | ||||
} | ||||
bool PythonQtShell_QWidgetAction::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 QWidgetAction::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QWidgetAction::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 QWidgetAction::eventFilter(arg__1, arg__2); | ||||
} | ||||
void PythonQtShell_QWidgetAction::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; | ||||
} | ||||
} | ||||
QWidgetAction::timerEvent(arg__1); | ||||
} | ||||
QWidgetAction* PythonQtWrapper_QWidgetAction::new_QWidgetAction(QObject* parent) | ||||
{ | ||||
return new PythonQtShell_QWidgetAction(parent); } | ||||
QWidget* PythonQtWrapper_QWidgetAction::createWidget(QWidgetAction* theWrappedObject, QWidget* parent) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QWidgetAction*)theWrappedObject)->promoted_createWidget(parent)); | ||||
} | ||||
QWidget* PythonQtWrapper_QWidgetAction::defaultWidget(QWidgetAction* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->defaultWidget()); | ||||
} | ||||
void PythonQtWrapper_QWidgetAction::deleteWidget(QWidgetAction* theWrappedObject, QWidget* widget) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWidgetAction*)theWrappedObject)->promoted_deleteWidget(widget)); | ||||
} | ||||
bool PythonQtWrapper_QWidgetAction::event(QWidgetAction* theWrappedObject, QEvent* arg__1) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QWidgetAction*)theWrappedObject)->promoted_event(arg__1)); | ||||
} | ||||
bool PythonQtWrapper_QWidgetAction::eventFilter(QWidgetAction* theWrappedObject, QObject* arg__1, QEvent* arg__2) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QWidgetAction*)theWrappedObject)->promoted_eventFilter(arg__1, arg__2)); | ||||
} | ||||
void PythonQtWrapper_QWidgetAction::releaseWidget(QWidgetAction* theWrappedObject, QWidget* widget) | ||||
{ | ||||
( theWrappedObject->releaseWidget(widget)); | ||||
} | ||||
QWidget* PythonQtWrapper_QWidgetAction::requestWidget(QWidgetAction* theWrappedObject, QWidget* parent) | ||||
{ | ||||
return ( theWrappedObject->requestWidget(parent)); | ||||
} | ||||
void PythonQtWrapper_QWidgetAction::setDefaultWidget(QWidgetAction* theWrappedObject, QWidget* w) | ||||
{ | ||||
( theWrappedObject->setDefaultWidget(w)); | ||||
} | ||||
PythonQtShell_QWidgetItem::~PythonQtShell_QWidgetItem() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
Qt::Orientations PythonQtShell_QWidgetItem::expandingDirections() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "expandingDirections"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"Qt::Orientations"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
Qt::Orientations 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("expandingDirections", methodInfo, result); | ||||
} else { | ||||
returnValue = *((Qt::Orientations*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QWidgetItem::expandingDirections(); | ||||
} | ||||
QRect PythonQtShell_QWidgetItem::geometry() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "geometry"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QRect"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QRect 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("geometry", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QRect*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QWidgetItem::geometry(); | ||||
} | ||||
bool PythonQtShell_QWidgetItem::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 QWidgetItem::hasHeightForWidth(); | ||||
} | ||||
int PythonQtShell_QWidgetItem::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 QWidgetItem::heightForWidth(arg__1); | ||||
} | ||||
void PythonQtShell_QWidgetItem::invalidate() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "invalidate"); | ||||
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; | ||||
} | ||||
} | ||||
QWidgetItem::invalidate(); | ||||
} | ||||
bool PythonQtShell_QWidgetItem::isEmpty() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isEmpty"); | ||||
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("isEmpty", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QWidgetItem::isEmpty(); | ||||
} | ||||
QLayout* PythonQtShell_QWidgetItem::layout() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "layout"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QLayout*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QLayout* 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("layout", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QLayout**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QWidgetItem::layout(); | ||||
} | ||||
QSize PythonQtShell_QWidgetItem::maximumSize() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "maximumSize"); | ||||
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("maximumSize", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QSize*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QWidgetItem::maximumSize(); | ||||
} | ||||
int PythonQtShell_QWidgetItem::minimumHeightForWidth(int arg__1) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "minimumHeightForWidth"); | ||||
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("minimumHeightForWidth", methodInfo, result); | ||||
} else { | ||||
returnValue = *((int*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QWidgetItem::minimumHeightForWidth(arg__1); | ||||
} | ||||
QSize PythonQtShell_QWidgetItem::minimumSize() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "minimumSize"); | ||||
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("minimumSize", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QSize*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QWidgetItem::minimumSize(); | ||||
} | ||||
void PythonQtShell_QWidgetItem::setGeometry(const QRect& arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setGeometry"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "const QRect&"}; | ||||
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; | ||||
} | ||||
} | ||||
QWidgetItem::setGeometry(arg__1); | ||||
} | ||||
QSize PythonQtShell_QWidgetItem::sizeHint() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sizeHint"); | ||||
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("sizeHint", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QSize*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QWidgetItem::sizeHint(); | ||||
} | ||||
QSpacerItem* PythonQtShell_QWidgetItem::spacerItem() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "spacerItem"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QSpacerItem*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QSpacerItem* 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("spacerItem", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QSpacerItem**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QWidgetItem::spacerItem(); | ||||
} | ||||
QWidget* PythonQtShell_QWidgetItem::widget() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "widget"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QWidget*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QWidget* 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("widget", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QWidget**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QWidgetItem::widget(); | ||||
} | ||||
QWidgetItem* PythonQtWrapper_QWidgetItem::new_QWidgetItem(QWidget* w) | ||||
{ | ||||
return new PythonQtShell_QWidgetItem(w); } | ||||
Qt::Orientations PythonQtWrapper_QWidgetItem::expandingDirections(QWidgetItem* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QWidgetItem*)theWrappedObject)->promoted_expandingDirections()); | ||||
} | ||||
QRect PythonQtWrapper_QWidgetItem::geometry(QWidgetItem* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QWidgetItem*)theWrappedObject)->promoted_geometry()); | ||||
} | ||||
bool PythonQtWrapper_QWidgetItem::hasHeightForWidth(QWidgetItem* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QWidgetItem*)theWrappedObject)->promoted_hasHeightForWidth()); | ||||
} | ||||
int PythonQtWrapper_QWidgetItem::heightForWidth(QWidgetItem* theWrappedObject, int arg__1) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QWidgetItem*)theWrappedObject)->promoted_heightForWidth(arg__1)); | ||||
} | ||||
bool PythonQtWrapper_QWidgetItem::isEmpty(QWidgetItem* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QWidgetItem*)theWrappedObject)->promoted_isEmpty()); | ||||
} | ||||
QSize PythonQtWrapper_QWidgetItem::maximumSize(QWidgetItem* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QWidgetItem*)theWrappedObject)->promoted_maximumSize()); | ||||
} | ||||
QSize PythonQtWrapper_QWidgetItem::minimumSize(QWidgetItem* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QWidgetItem*)theWrappedObject)->promoted_minimumSize()); | ||||
} | ||||
void PythonQtWrapper_QWidgetItem::setGeometry(QWidgetItem* theWrappedObject, const QRect& arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWidgetItem*)theWrappedObject)->promoted_setGeometry(arg__1)); | ||||
} | ||||
QSize PythonQtWrapper_QWidgetItem::sizeHint(QWidgetItem* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QWidgetItem*)theWrappedObject)->promoted_sizeHint()); | ||||
} | ||||
QWidget* PythonQtWrapper_QWidgetItem::widget(QWidgetItem* theWrappedObject) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QWidgetItem*)theWrappedObject)->promoted_widget()); | ||||
} | ||||
QWindowStateChangeEvent* PythonQtWrapper_QWindowStateChangeEvent::new_QWindowStateChangeEvent(Qt::WindowStates aOldState) | ||||
{ | ||||
return new QWindowStateChangeEvent(aOldState); } | ||||
QWindowStateChangeEvent* PythonQtWrapper_QWindowStateChangeEvent::new_QWindowStateChangeEvent(Qt::WindowStates aOldState, bool isOverride) | ||||
{ | ||||
return new QWindowStateChangeEvent(aOldState, isOverride); } | ||||
bool PythonQtWrapper_QWindowStateChangeEvent::isOverride(QWindowStateChangeEvent* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isOverride()); | ||||
} | ||||
Qt::WindowStates PythonQtWrapper_QWindowStateChangeEvent::oldState(QWindowStateChangeEvent* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->oldState()); | ||||
} | ||||
PythonQtShell_QWindowsStyle::~PythonQtShell_QWindowsStyle() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_QWindowsStyle::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; | ||||
} | ||||
} | ||||
QWindowsStyle::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWindowsStyle::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; | ||||
} | ||||
} | ||||
QWindowsStyle::customEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWindowsStyle::drawComplexControl(QStyle::ComplexControl cc, const QStyleOptionComplex* opt, QPainter* p, const QWidget* w) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "drawComplexControl"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QStyle::ComplexControl" , "const QStyleOptionComplex*" , "QPainter*" , "const QWidget*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList); | ||||
void* args[5] = {NULL, (void*)&cc, (void*)&opt, (void*)&p, (void*)&w}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QWindowsStyle::drawComplexControl(cc, opt, p, w); | ||||
} | ||||
void PythonQtShell_QWindowsStyle::drawControl(QStyle::ControlElement element, const QStyleOption* opt, QPainter* p, const QWidget* w) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "drawControl"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QStyle::ControlElement" , "const QStyleOption*" , "QPainter*" , "const QWidget*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList); | ||||
void* args[5] = {NULL, (void*)&element, (void*)&opt, (void*)&p, (void*)&w}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QWindowsStyle::drawControl(element, opt, p, w); | ||||
} | ||||
void PythonQtShell_QWindowsStyle::drawItemPixmap(QPainter* painter, const QRect& rect, int alignment, const QPixmap& pixmap) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "drawItemPixmap"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QPainter*" , "const QRect&" , "int" , "const QPixmap&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList); | ||||
void* args[5] = {NULL, (void*)&painter, (void*)&rect, (void*)&alignment, (void*)&pixmap}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QWindowsStyle::drawItemPixmap(painter, rect, alignment, pixmap); | ||||
} | ||||
void PythonQtShell_QWindowsStyle::drawItemText(QPainter* painter, const QRect& rect, int flags, const QPalette& pal, bool enabled, const QString& text, QPalette::ColorRole textRole) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "drawItemText"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QPainter*" , "const QRect&" , "int" , "const QPalette&" , "bool" , "const QString&" , "QPalette::ColorRole"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(8, argumentList); | ||||
void* args[8] = {NULL, (void*)&painter, (void*)&rect, (void*)&flags, (void*)&pal, (void*)&enabled, (void*)&text, (void*)&textRole}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QWindowsStyle::drawItemText(painter, rect, flags, pal, enabled, text, textRole); | ||||
} | ||||
void PythonQtShell_QWindowsStyle::drawPrimitive(QStyle::PrimitiveElement pe, const QStyleOption* opt, QPainter* p, const QWidget* w) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "drawPrimitive"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QStyle::PrimitiveElement" , "const QStyleOption*" , "QPainter*" , "const QWidget*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList); | ||||
void* args[5] = {NULL, (void*)&pe, (void*)&opt, (void*)&p, (void*)&w}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QWindowsStyle::drawPrimitive(pe, opt, p, w); | ||||
} | ||||
bool PythonQtShell_QWindowsStyle::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 QWindowsStyle::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QWindowsStyle::eventFilter(QObject* o, QEvent* e) | ||||
{ | ||||
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*)&o, (void*)&e}; | ||||
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 QWindowsStyle::eventFilter(o, e); | ||||
} | ||||
QPixmap PythonQtShell_QWindowsStyle::generatedIconPixmap(QIcon::Mode iconMode, const QPixmap& pixmap, const QStyleOption* opt) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "generatedIconPixmap"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QPixmap" , "QIcon::Mode" , "const QPixmap&" , "const QStyleOption*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
QPixmap returnValue; | ||||
void* args[4] = {NULL, (void*)&iconMode, (void*)&pixmap, (void*)&opt}; | ||||
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("generatedIconPixmap", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QPixmap*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QWindowsStyle::generatedIconPixmap(iconMode, pixmap, opt); | ||||
} | ||||
QStyle::SubControl PythonQtShell_QWindowsStyle::hitTestComplexControl(QStyle::ComplexControl cc, const QStyleOptionComplex* opt, const QPoint& pt, const QWidget* w) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hitTestComplexControl"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QStyle::SubControl" , "QStyle::ComplexControl" , "const QStyleOptionComplex*" , "const QPoint&" , "const QWidget*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList); | ||||
QStyle::SubControl returnValue; | ||||
void* args[5] = {NULL, (void*)&cc, (void*)&opt, (void*)&pt, (void*)&w}; | ||||
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("hitTestComplexControl", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QStyle::SubControl*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QWindowsStyle::hitTestComplexControl(cc, opt, pt, w); | ||||
} | ||||
QRect PythonQtShell_QWindowsStyle::itemPixmapRect(const QRect& r, int flags, const QPixmap& pixmap) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "itemPixmapRect"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QRect" , "const QRect&" , "int" , "const QPixmap&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
QRect returnValue; | ||||
void* args[4] = {NULL, (void*)&r, (void*)&flags, (void*)&pixmap}; | ||||
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("itemPixmapRect", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QRect*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QWindowsStyle::itemPixmapRect(r, flags, pixmap); | ||||
} | ||||
int PythonQtShell_QWindowsStyle::pixelMetric(QStyle::PixelMetric pm, const QStyleOption* option, const QWidget* widget) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "pixelMetric"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"int" , "QStyle::PixelMetric" , "const QStyleOption*" , "const QWidget*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
int returnValue; | ||||
void* args[4] = {NULL, (void*)&pm, (void*)&option, (void*)&widget}; | ||||
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("pixelMetric", methodInfo, result); | ||||
} else { | ||||
returnValue = *((int*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QWindowsStyle::pixelMetric(pm, option, widget); | ||||
} | ||||
void PythonQtShell_QWindowsStyle::polish(QApplication* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "polish"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QApplication*"}; | ||||
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; | ||||
} | ||||
} | ||||
QWindowsStyle::polish(arg__1); | ||||
} | ||||
void PythonQtShell_QWindowsStyle::polish(QPalette& arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "polish"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QPalette&"}; | ||||
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; | ||||
} | ||||
} | ||||
QWindowsStyle::polish(arg__1); | ||||
} | ||||
void PythonQtShell_QWindowsStyle::polish(QWidget* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "polish"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QWidget*"}; | ||||
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; | ||||
} | ||||
} | ||||
QWindowsStyle::polish(arg__1); | ||||
} | ||||
QSize PythonQtShell_QWindowsStyle::sizeFromContents(QStyle::ContentsType ct, const QStyleOption* opt, const QSize& contentsSize, const QWidget* widget) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sizeFromContents"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QSize" , "QStyle::ContentsType" , "const QStyleOption*" , "const QSize&" , "const QWidget*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList); | ||||
QSize returnValue; | ||||
void* args[5] = {NULL, (void*)&ct, (void*)&opt, (void*)&contentsSize, (void*)&widget}; | ||||
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("sizeFromContents", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QSize*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QWindowsStyle::sizeFromContents(ct, opt, contentsSize, widget); | ||||
} | ||||
QPalette PythonQtShell_QWindowsStyle::standardPalette() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "standardPalette"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QPalette"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QPalette 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("standardPalette", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QPalette*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QWindowsStyle::standardPalette(); | ||||
} | ||||
QPixmap PythonQtShell_QWindowsStyle::standardPixmap(QStyle::StandardPixmap standardPixmap, const QStyleOption* opt, const QWidget* widget) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "standardPixmap"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QPixmap" , "QStyle::StandardPixmap" , "const QStyleOption*" , "const QWidget*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
QPixmap returnValue; | ||||
void* args[4] = {NULL, (void*)&standardPixmap, (void*)&opt, (void*)&widget}; | ||||
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("standardPixmap", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QPixmap*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QPixmap(); | ||||
} | ||||
int PythonQtShell_QWindowsStyle::styleHint(QStyle::StyleHint hint, const QStyleOption* opt, const QWidget* widget, QStyleHintReturn* returnData) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "styleHint"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"int" , "QStyle::StyleHint" , "const QStyleOption*" , "const QWidget*" , "QStyleHintReturn*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList); | ||||
int returnValue; | ||||
void* args[5] = {NULL, (void*)&hint, (void*)&opt, (void*)&widget, (void*)&returnData}; | ||||
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("styleHint", methodInfo, result); | ||||
} else { | ||||
returnValue = *((int*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QWindowsStyle::styleHint(hint, opt, widget, returnData); | ||||
} | ||||
QRect PythonQtShell_QWindowsStyle::subControlRect(QStyle::ComplexControl cc, const QStyleOptionComplex* opt, QStyle::SubControl sc, const QWidget* w) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "subControlRect"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QRect" , "QStyle::ComplexControl" , "const QStyleOptionComplex*" , "QStyle::SubControl" , "const QWidget*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList); | ||||
QRect returnValue; | ||||
void* args[5] = {NULL, (void*)&cc, (void*)&opt, (void*)&sc, (void*)&w}; | ||||
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("subControlRect", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QRect*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QWindowsStyle::subControlRect(cc, opt, sc, w); | ||||
} | ||||
QRect PythonQtShell_QWindowsStyle::subElementRect(QStyle::SubElement r, const QStyleOption* opt, const QWidget* widget) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "subElementRect"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QRect" , "QStyle::SubElement" , "const QStyleOption*" , "const QWidget*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
QRect returnValue; | ||||
void* args[4] = {NULL, (void*)&r, (void*)&opt, (void*)&widget}; | ||||
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("subElementRect", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QRect*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QWindowsStyle::subElementRect(r, opt, widget); | ||||
} | ||||
void PythonQtShell_QWindowsStyle::timerEvent(QTimerEvent* event) | ||||
{ | ||||
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*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QWindowsStyle::timerEvent(event); | ||||
} | ||||
void PythonQtShell_QWindowsStyle::unpolish(QApplication* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "unpolish"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QApplication*"}; | ||||
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; | ||||
} | ||||
} | ||||
QWindowsStyle::unpolish(arg__1); | ||||
} | ||||
void PythonQtShell_QWindowsStyle::unpolish(QWidget* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "unpolish"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QWidget*"}; | ||||
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; | ||||
} | ||||
} | ||||
QWindowsStyle::unpolish(arg__1); | ||||
} | ||||
QWindowsStyle* PythonQtWrapper_QWindowsStyle::new_QWindowsStyle() | ||||
{ | ||||
return new PythonQtShell_QWindowsStyle(); } | ||||
void PythonQtWrapper_QWindowsStyle::drawComplexControl(QWindowsStyle* theWrappedObject, QStyle::ComplexControl cc, const QStyleOptionComplex* opt, QPainter* p, const QWidget* w) const | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWindowsStyle*)theWrappedObject)->promoted_drawComplexControl(cc, opt, p, w)); | ||||
} | ||||
void PythonQtWrapper_QWindowsStyle::drawControl(QWindowsStyle* theWrappedObject, QStyle::ControlElement element, const QStyleOption* opt, QPainter* p, const QWidget* w) const | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWindowsStyle*)theWrappedObject)->promoted_drawControl(element, opt, p, w)); | ||||
} | ||||
void PythonQtWrapper_QWindowsStyle::drawPrimitive(QWindowsStyle* theWrappedObject, QStyle::PrimitiveElement pe, const QStyleOption* opt, QPainter* p, const QWidget* w) const | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWindowsStyle*)theWrappedObject)->promoted_drawPrimitive(pe, opt, p, w)); | ||||
} | ||||
bool PythonQtWrapper_QWindowsStyle::eventFilter(QWindowsStyle* theWrappedObject, QObject* o, QEvent* e) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QWindowsStyle*)theWrappedObject)->promoted_eventFilter(o, e)); | ||||
} | ||||
int PythonQtWrapper_QWindowsStyle::pixelMetric(QWindowsStyle* theWrappedObject, QStyle::PixelMetric pm, const QStyleOption* option, const QWidget* widget) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QWindowsStyle*)theWrappedObject)->promoted_pixelMetric(pm, option, widget)); | ||||
} | ||||
void PythonQtWrapper_QWindowsStyle::polish(QWindowsStyle* theWrappedObject, QApplication* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWindowsStyle*)theWrappedObject)->promoted_polish(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWindowsStyle::polish(QWindowsStyle* theWrappedObject, QPalette& arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWindowsStyle*)theWrappedObject)->promoted_polish(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWindowsStyle::polish(QWindowsStyle* theWrappedObject, QWidget* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWindowsStyle*)theWrappedObject)->promoted_polish(arg__1)); | ||||
} | ||||
QSize PythonQtWrapper_QWindowsStyle::sizeFromContents(QWindowsStyle* theWrappedObject, QStyle::ContentsType ct, const QStyleOption* opt, const QSize& contentsSize, const QWidget* widget) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QWindowsStyle*)theWrappedObject)->promoted_sizeFromContents(ct, opt, contentsSize, widget)); | ||||
} | ||||
int PythonQtWrapper_QWindowsStyle::styleHint(QWindowsStyle* theWrappedObject, QStyle::StyleHint hint, const QStyleOption* opt, const QWidget* widget, QStyleHintReturn* returnData) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QWindowsStyle*)theWrappedObject)->promoted_styleHint(hint, opt, widget, returnData)); | ||||
} | ||||
QRect PythonQtWrapper_QWindowsStyle::subElementRect(QWindowsStyle* theWrappedObject, QStyle::SubElement r, const QStyleOption* opt, const QWidget* widget) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QWindowsStyle*)theWrappedObject)->promoted_subElementRect(r, opt, widget)); | ||||
} | ||||
void PythonQtWrapper_QWindowsStyle::timerEvent(QWindowsStyle* theWrappedObject, QTimerEvent* event) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWindowsStyle*)theWrappedObject)->promoted_timerEvent(event)); | ||||
} | ||||
void PythonQtWrapper_QWindowsStyle::unpolish(QWindowsStyle* theWrappedObject, QApplication* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWindowsStyle*)theWrappedObject)->promoted_unpolish(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWindowsStyle::unpolish(QWindowsStyle* theWrappedObject, QWidget* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWindowsStyle*)theWrappedObject)->promoted_unpolish(arg__1)); | ||||
} | ||||
PythonQtShell_QWizard::~PythonQtShell_QWizard() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_QWizard::accept() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "accept"); | ||||
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; | ||||
} | ||||
} | ||||
QWizard::accept(); | ||||
} | ||||
void PythonQtShell_QWizard::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; | ||||
} | ||||
} | ||||
QWizard::actionEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWizard::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; | ||||
} | ||||
} | ||||
QWizard::changeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWizard::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; | ||||
} | ||||
} | ||||
QWizard::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWizard::cleanupPage(int id) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "cleanupPage"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&id}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QWizard::cleanupPage(id); | ||||
} | ||||
void PythonQtShell_QWizard::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; | ||||
} | ||||
} | ||||
QWizard::closeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWizard::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; | ||||
} | ||||
} | ||||
QWizard::contextMenuEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWizard::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; | ||||
} | ||||
} | ||||
QWizard::customEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QWizard::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 QWizard::devType(); | ||||
} | ||||
void PythonQtShell_QWizard::done(int result) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "done"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&result}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QWizard::done(result); | ||||
} | ||||
void PythonQtShell_QWizard::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; | ||||
} | ||||
} | ||||
QWizard::dragEnterEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWizard::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; | ||||
} | ||||
} | ||||
QWizard::dragLeaveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWizard::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; | ||||
} | ||||
} | ||||
QWizard::dragMoveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWizard::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; | ||||
} | ||||
} | ||||
QWizard::dropEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWizard::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; | ||||
} | ||||
} | ||||
QWizard::enterEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QWizard::event(QEvent* event) | ||||
{ | ||||
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*)&event}; | ||||
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 QWizard::event(event); | ||||
} | ||||
bool PythonQtShell_QWizard::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 QWizard::eventFilter(arg__1, arg__2); | ||||
} | ||||
void PythonQtShell_QWizard::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; | ||||
} | ||||
} | ||||
QWizard::focusInEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QWizard::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 QWizard::focusNextPrevChild(next); | ||||
} | ||||
void PythonQtShell_QWizard::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; | ||||
} | ||||
} | ||||
QWizard::focusOutEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QWizard::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 QWizard::heightForWidth(arg__1); | ||||
} | ||||
void PythonQtShell_QWizard::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; | ||||
} | ||||
} | ||||
QWizard::hideEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWizard::initializePage(int id) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initializePage"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&id}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QWizard::initializePage(id); | ||||
} | ||||
void PythonQtShell_QWizard::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; | ||||
} | ||||
} | ||||
QWizard::inputMethodEvent(arg__1); | ||||
} | ||||
QVariant PythonQtShell_QWizard::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 QWizard::inputMethodQuery(arg__1); | ||||
} | ||||
void PythonQtShell_QWizard::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; | ||||
} | ||||
} | ||||
QWizard::keyPressEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWizard::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; | ||||
} | ||||
} | ||||
QWizard::keyReleaseEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWizard::languageChange() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "languageChange"); | ||||
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; | ||||
} | ||||
} | ||||
QWizard::languageChange(); | ||||
} | ||||
void PythonQtShell_QWizard::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; | ||||
} | ||||
} | ||||
QWizard::leaveEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QWizard::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 QWizard::metric(arg__1); | ||||
} | ||||
void PythonQtShell_QWizard::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; | ||||
} | ||||
} | ||||
QWizard::mouseDoubleClickEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWizard::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; | ||||
} | ||||
} | ||||
QWizard::mouseMoveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWizard::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; | ||||
} | ||||
} | ||||
QWizard::mousePressEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWizard::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; | ||||
} | ||||
} | ||||
QWizard::mouseReleaseEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWizard::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; | ||||
} | ||||
} | ||||
QWizard::moveEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QWizard::nextId() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nextId"); | ||||
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("nextId", methodInfo, result); | ||||
} else { | ||||
returnValue = *((int*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QWizard::nextId(); | ||||
} | ||||
QPaintEngine* PythonQtShell_QWizard::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 QWizard::paintEngine(); | ||||
} | ||||
void PythonQtShell_QWizard::paintEvent(QPaintEvent* event) | ||||
{ | ||||
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*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QWizard::paintEvent(event); | ||||
} | ||||
void PythonQtShell_QWizard::reject() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reject"); | ||||
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; | ||||
} | ||||
} | ||||
QWizard::reject(); | ||||
} | ||||
void PythonQtShell_QWizard::resizeEvent(QResizeEvent* event) | ||||
{ | ||||
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*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QWizard::resizeEvent(event); | ||||
} | ||||
void PythonQtShell_QWizard::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; | ||||
} | ||||
} | ||||
QWizard::showEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWizard::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; | ||||
} | ||||
} | ||||
QWizard::tabletEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWizard::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; | ||||
} | ||||
} | ||||
QWizard::timerEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QWizard::validateCurrentPage() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "validateCurrentPage"); | ||||
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("validateCurrentPage", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QWizard::validateCurrentPage(); | ||||
} | ||||
void PythonQtShell_QWizard::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; | ||||
} | ||||
} | ||||
QWizard::wheelEvent(arg__1); | ||||
} | ||||
QWizard* PythonQtWrapper_QWizard::new_QWizard(QWidget* parent, Qt::WindowFlags flags) | ||||
{ | ||||
return new PythonQtShell_QWizard(parent, flags); } | ||||
int PythonQtWrapper_QWizard::addPage(QWizard* theWrappedObject, QWizardPage* page) | ||||
{ | ||||
return ( theWrappedObject->addPage(page)); | ||||
} | ||||
QAbstractButton* PythonQtWrapper_QWizard::button(QWizard* theWrappedObject, QWizard::WizardButton which) const | ||||
{ | ||||
return ( theWrappedObject->button(which)); | ||||
} | ||||
QString PythonQtWrapper_QWizard::buttonText(QWizard* theWrappedObject, QWizard::WizardButton which) const | ||||
{ | ||||
return ( theWrappedObject->buttonText(which)); | ||||
} | ||||
void PythonQtWrapper_QWizard::cleanupPage(QWizard* theWrappedObject, int id) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWizard*)theWrappedObject)->promoted_cleanupPage(id)); | ||||
} | ||||
int PythonQtWrapper_QWizard::currentId(QWizard* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->currentId()); | ||||
} | ||||
QWizardPage* PythonQtWrapper_QWizard::currentPage(QWizard* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->currentPage()); | ||||
} | ||||
void PythonQtWrapper_QWizard::done(QWizard* theWrappedObject, int result) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWizard*)theWrappedObject)->promoted_done(result)); | ||||
} | ||||
bool PythonQtWrapper_QWizard::event(QWizard* theWrappedObject, QEvent* event) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QWizard*)theWrappedObject)->promoted_event(event)); | ||||
} | ||||
QVariant PythonQtWrapper_QWizard::field(QWizard* theWrappedObject, const QString& name) const | ||||
{ | ||||
return ( theWrappedObject->field(name)); | ||||
} | ||||
bool PythonQtWrapper_QWizard::hasVisitedPage(QWizard* theWrappedObject, int id) const | ||||
{ | ||||
return ( theWrappedObject->hasVisitedPage(id)); | ||||
} | ||||
void PythonQtWrapper_QWizard::initializePage(QWizard* theWrappedObject, int id) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWizard*)theWrappedObject)->promoted_initializePage(id)); | ||||
} | ||||
int PythonQtWrapper_QWizard::nextId(QWizard* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QWizard*)theWrappedObject)->promoted_nextId()); | ||||
} | ||||
QWizard::WizardOptions PythonQtWrapper_QWizard::options(QWizard* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->options()); | ||||
} | ||||
QWizardPage* PythonQtWrapper_QWizard::page(QWizard* theWrappedObject, int id) const | ||||
{ | ||||
return ( theWrappedObject->page(id)); | ||||
} | ||||
QList<int > PythonQtWrapper_QWizard::pageIds(QWizard* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->pageIds()); | ||||
} | ||||
void PythonQtWrapper_QWizard::paintEvent(QWizard* theWrappedObject, QPaintEvent* event) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWizard*)theWrappedObject)->promoted_paintEvent(event)); | ||||
} | ||||
QPixmap PythonQtWrapper_QWizard::pixmap(QWizard* theWrappedObject, QWizard::WizardPixmap which) const | ||||
{ | ||||
return ( theWrappedObject->pixmap(which)); | ||||
} | ||||
void PythonQtWrapper_QWizard::removePage(QWizard* theWrappedObject, int id) | ||||
{ | ||||
( theWrappedObject->removePage(id)); | ||||
} | ||||
void PythonQtWrapper_QWizard::resizeEvent(QWizard* theWrappedObject, QResizeEvent* event) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWizard*)theWrappedObject)->promoted_resizeEvent(event)); | ||||
} | ||||
void PythonQtWrapper_QWizard::setButton(QWizard* theWrappedObject, QWizard::WizardButton which, QAbstractButton* button) | ||||
{ | ||||
( theWrappedObject->setButton(which, button)); | ||||
} | ||||
void PythonQtWrapper_QWizard::setButtonLayout(QWizard* theWrappedObject, const QList<QWizard::WizardButton >& layout) | ||||
{ | ||||
( theWrappedObject->setButtonLayout(layout)); | ||||
} | ||||
void PythonQtWrapper_QWizard::setButtonText(QWizard* theWrappedObject, QWizard::WizardButton which, const QString& text) | ||||
{ | ||||
( theWrappedObject->setButtonText(which, text)); | ||||
} | ||||
void PythonQtWrapper_QWizard::setField(QWizard* theWrappedObject, const QString& name, const QVariant& value) | ||||
{ | ||||
( theWrappedObject->setField(name, value)); | ||||
} | ||||
void PythonQtWrapper_QWizard::setOption(QWizard* theWrappedObject, QWizard::WizardOption option, bool on) | ||||
{ | ||||
( theWrappedObject->setOption(option, on)); | ||||
} | ||||
void PythonQtWrapper_QWizard::setOptions(QWizard* theWrappedObject, QWizard::WizardOptions options) | ||||
{ | ||||
( theWrappedObject->setOptions(options)); | ||||
} | ||||
void PythonQtWrapper_QWizard::setPage(QWizard* theWrappedObject, int id, QWizardPage* page) | ||||
{ | ||||
( theWrappedObject->setPage(id, page)); | ||||
} | ||||
void PythonQtWrapper_QWizard::setPixmap(QWizard* theWrappedObject, QWizard::WizardPixmap which, const QPixmap& pixmap) | ||||
{ | ||||
( theWrappedObject->setPixmap(which, pixmap)); | ||||
} | ||||
void PythonQtWrapper_QWizard::setSideWidget(QWizard* theWrappedObject, QWidget* widget) | ||||
{ | ||||
( theWrappedObject->setSideWidget(widget)); | ||||
} | ||||
void PythonQtWrapper_QWizard::setStartId(QWizard* theWrappedObject, int id) | ||||
{ | ||||
( theWrappedObject->setStartId(id)); | ||||
} | ||||
void PythonQtWrapper_QWizard::setSubTitleFormat(QWizard* theWrappedObject, Qt::TextFormat format) | ||||
{ | ||||
( theWrappedObject->setSubTitleFormat(format)); | ||||
} | ||||
void PythonQtWrapper_QWizard::setTitleFormat(QWizard* theWrappedObject, Qt::TextFormat format) | ||||
{ | ||||
( theWrappedObject->setTitleFormat(format)); | ||||
} | ||||
void PythonQtWrapper_QWizard::setVisible(QWizard* theWrappedObject, bool visible) | ||||
{ | ||||
( theWrappedObject->setVisible(visible)); | ||||
} | ||||
void PythonQtWrapper_QWizard::setWizardStyle(QWizard* theWrappedObject, QWizard::WizardStyle style) | ||||
{ | ||||
( theWrappedObject->setWizardStyle(style)); | ||||
} | ||||
QWidget* PythonQtWrapper_QWizard::sideWidget(QWizard* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->sideWidget()); | ||||
} | ||||
QSize PythonQtWrapper_QWizard::sizeHint(QWizard* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->sizeHint()); | ||||
} | ||||
int PythonQtWrapper_QWizard::startId(QWizard* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->startId()); | ||||
} | ||||
Qt::TextFormat PythonQtWrapper_QWizard::subTitleFormat(QWizard* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->subTitleFormat()); | ||||
} | ||||
bool PythonQtWrapper_QWizard::testOption(QWizard* theWrappedObject, QWizard::WizardOption option) const | ||||
{ | ||||
return ( theWrappedObject->testOption(option)); | ||||
} | ||||
Qt::TextFormat PythonQtWrapper_QWizard::titleFormat(QWizard* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->titleFormat()); | ||||
} | ||||
bool PythonQtWrapper_QWizard::validateCurrentPage(QWizard* theWrappedObject) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QWizard*)theWrappedObject)->promoted_validateCurrentPage()); | ||||
} | ||||
QList<int > PythonQtWrapper_QWizard::visitedPages(QWizard* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->visitedPages()); | ||||
} | ||||
QWizard::WizardStyle PythonQtWrapper_QWizard::wizardStyle(QWizard* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->wizardStyle()); | ||||
} | ||||
PythonQtShell_QWizardPage::~PythonQtShell_QWizardPage() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_QWizardPage::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; | ||||
} | ||||
} | ||||
QWizardPage::actionEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWizardPage::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; | ||||
} | ||||
} | ||||
QWizardPage::changeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWizardPage::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; | ||||
} | ||||
} | ||||
QWizardPage::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWizardPage::cleanupPage() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "cleanupPage"); | ||||
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; | ||||
} | ||||
} | ||||
QWizardPage::cleanupPage(); | ||||
} | ||||
void PythonQtShell_QWizardPage::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; | ||||
} | ||||
} | ||||
QWizardPage::closeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWizardPage::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; | ||||
} | ||||
} | ||||
QWizardPage::contextMenuEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWizardPage::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; | ||||
} | ||||
} | ||||
QWizardPage::customEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QWizardPage::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 QWizardPage::devType(); | ||||
} | ||||
void PythonQtShell_QWizardPage::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; | ||||
} | ||||
} | ||||
QWizardPage::dragEnterEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWizardPage::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; | ||||
} | ||||
} | ||||
QWizardPage::dragLeaveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWizardPage::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; | ||||
} | ||||
} | ||||
QWizardPage::dragMoveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWizardPage::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; | ||||
} | ||||
} | ||||
QWizardPage::dropEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWizardPage::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; | ||||
} | ||||
} | ||||
QWizardPage::enterEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QWizardPage::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 QWizardPage::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QWizardPage::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 QWizardPage::eventFilter(arg__1, arg__2); | ||||
} | ||||
void PythonQtShell_QWizardPage::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; | ||||
} | ||||
} | ||||
QWizardPage::focusInEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QWizardPage::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 QWizardPage::focusNextPrevChild(next); | ||||
} | ||||
void PythonQtShell_QWizardPage::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; | ||||
} | ||||
} | ||||
QWizardPage::focusOutEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QWizardPage::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 QWizardPage::heightForWidth(arg__1); | ||||
} | ||||
void PythonQtShell_QWizardPage::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; | ||||
} | ||||
} | ||||
QWizardPage::hideEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWizardPage::initializePage() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "initializePage"); | ||||
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; | ||||
} | ||||
} | ||||
QWizardPage::initializePage(); | ||||
} | ||||
void PythonQtShell_QWizardPage::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; | ||||
} | ||||
} | ||||
QWizardPage::inputMethodEvent(arg__1); | ||||
} | ||||
QVariant PythonQtShell_QWizardPage::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 QWizardPage::inputMethodQuery(arg__1); | ||||
} | ||||
bool PythonQtShell_QWizardPage::isComplete() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isComplete"); | ||||
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("isComplete", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QWizardPage::isComplete(); | ||||
} | ||||
void PythonQtShell_QWizardPage::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; | ||||
} | ||||
} | ||||
QWizardPage::keyPressEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWizardPage::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; | ||||
} | ||||
} | ||||
QWizardPage::keyReleaseEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWizardPage::languageChange() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "languageChange"); | ||||
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; | ||||
} | ||||
} | ||||
QWizardPage::languageChange(); | ||||
} | ||||
void PythonQtShell_QWizardPage::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; | ||||
} | ||||
} | ||||
QWizardPage::leaveEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QWizardPage::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 QWizardPage::metric(arg__1); | ||||
} | ||||
QSize PythonQtShell_QWizardPage::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 QWizardPage::minimumSizeHint(); | ||||
} | ||||
void PythonQtShell_QWizardPage::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; | ||||
} | ||||
} | ||||
QWizardPage::mouseDoubleClickEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWizardPage::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; | ||||
} | ||||
} | ||||
QWizardPage::mouseMoveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWizardPage::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; | ||||
} | ||||
} | ||||
QWizardPage::mousePressEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWizardPage::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; | ||||
} | ||||
} | ||||
QWizardPage::mouseReleaseEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWizardPage::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; | ||||
} | ||||
} | ||||
QWizardPage::moveEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QWizardPage::nextId() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nextId"); | ||||
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("nextId", methodInfo, result); | ||||
} else { | ||||
returnValue = *((int*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QWizardPage::nextId(); | ||||
} | ||||
QPaintEngine* PythonQtShell_QWizardPage::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 QWizardPage::paintEngine(); | ||||
} | ||||
void PythonQtShell_QWizardPage::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; | ||||
} | ||||
} | ||||
QWizardPage::paintEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWizardPage::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; | ||||
} | ||||
} | ||||
QWizardPage::resizeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWizardPage::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; | ||||
} | ||||
} | ||||
QWizardPage::showEvent(arg__1); | ||||
} | ||||
QSize PythonQtShell_QWizardPage::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 QWizardPage::sizeHint(); | ||||
} | ||||
void PythonQtShell_QWizardPage::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; | ||||
} | ||||
} | ||||
QWizardPage::tabletEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWizardPage::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; | ||||
} | ||||
} | ||||
QWizardPage::timerEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QWizardPage::validatePage() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "validatePage"); | ||||
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("validatePage", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QWizardPage::validatePage(); | ||||
} | ||||
void PythonQtShell_QWizardPage::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; | ||||
} | ||||
} | ||||
QWizardPage::wheelEvent(arg__1); | ||||
} | ||||
QWizardPage* PythonQtWrapper_QWizardPage::new_QWizardPage(QWidget* parent) | ||||
{ | ||||
return new PythonQtShell_QWizardPage(parent); } | ||||
QString PythonQtWrapper_QWizardPage::buttonText(QWizardPage* theWrappedObject, QWizard::WizardButton which) const | ||||
{ | ||||
return ( theWrappedObject->buttonText(which)); | ||||
} | ||||
void PythonQtWrapper_QWizardPage::cleanupPage(QWizardPage* theWrappedObject) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWizardPage*)theWrappedObject)->promoted_cleanupPage()); | ||||
} | ||||
void PythonQtWrapper_QWizardPage::initializePage(QWizardPage* theWrappedObject) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWizardPage*)theWrappedObject)->promoted_initializePage()); | ||||
} | ||||
bool PythonQtWrapper_QWizardPage::isCommitPage(QWizardPage* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isCommitPage()); | ||||
} | ||||
bool PythonQtWrapper_QWizardPage::isComplete(QWizardPage* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QWizardPage*)theWrappedObject)->promoted_isComplete()); | ||||
} | ||||
bool PythonQtWrapper_QWizardPage::isFinalPage(QWizardPage* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isFinalPage()); | ||||
} | ||||
int PythonQtWrapper_QWizardPage::nextId(QWizardPage* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QWizardPage*)theWrappedObject)->promoted_nextId()); | ||||
} | ||||
QPixmap PythonQtWrapper_QWizardPage::pixmap(QWizardPage* theWrappedObject, QWizard::WizardPixmap which) const | ||||
{ | ||||
return ( theWrappedObject->pixmap(which)); | ||||
} | ||||
void PythonQtWrapper_QWizardPage::setButtonText(QWizardPage* theWrappedObject, QWizard::WizardButton which, const QString& text) | ||||
{ | ||||
( theWrappedObject->setButtonText(which, text)); | ||||
} | ||||
void PythonQtWrapper_QWizardPage::setCommitPage(QWizardPage* theWrappedObject, bool commitPage) | ||||
{ | ||||
( theWrappedObject->setCommitPage(commitPage)); | ||||
} | ||||
void PythonQtWrapper_QWizardPage::setFinalPage(QWizardPage* theWrappedObject, bool finalPage) | ||||
{ | ||||
( theWrappedObject->setFinalPage(finalPage)); | ||||
} | ||||
void PythonQtWrapper_QWizardPage::setPixmap(QWizardPage* theWrappedObject, QWizard::WizardPixmap which, const QPixmap& pixmap) | ||||
{ | ||||
( theWrappedObject->setPixmap(which, pixmap)); | ||||
} | ||||
void PythonQtWrapper_QWizardPage::setSubTitle(QWizardPage* theWrappedObject, const QString& subTitle) | ||||
{ | ||||
( theWrappedObject->setSubTitle(subTitle)); | ||||
} | ||||
void PythonQtWrapper_QWizardPage::setTitle(QWizardPage* theWrappedObject, const QString& title) | ||||
{ | ||||
( theWrappedObject->setTitle(title)); | ||||
} | ||||
QString PythonQtWrapper_QWizardPage::subTitle(QWizardPage* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->subTitle()); | ||||
} | ||||
QString PythonQtWrapper_QWizardPage::title(QWizardPage* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->title()); | ||||
} | ||||
bool PythonQtWrapper_QWizardPage::validatePage(QWizardPage* theWrappedObject) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QWizardPage*)theWrappedObject)->promoted_validatePage()); | ||||
} | ||||
PythonQtShell_QWorkspace::~PythonQtShell_QWorkspace() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_QWorkspace::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; | ||||
} | ||||
} | ||||
QWorkspace::actionEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWorkspace::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; | ||||
} | ||||
} | ||||
QWorkspace::changeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWorkspace::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; | ||||
} | ||||
} | ||||
QWorkspace::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWorkspace::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; | ||||
} | ||||
} | ||||
QWorkspace::closeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWorkspace::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; | ||||
} | ||||
} | ||||
QWorkspace::contextMenuEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWorkspace::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; | ||||
} | ||||
} | ||||
QWorkspace::customEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QWorkspace::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 QWorkspace::devType(); | ||||
} | ||||
void PythonQtShell_QWorkspace::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; | ||||
} | ||||
} | ||||
QWorkspace::dragEnterEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWorkspace::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; | ||||
} | ||||
} | ||||
QWorkspace::dragLeaveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWorkspace::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; | ||||
} | ||||
} | ||||
QWorkspace::dragMoveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWorkspace::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; | ||||
} | ||||
} | ||||
QWorkspace::dropEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWorkspace::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; | ||||
} | ||||
} | ||||
QWorkspace::enterEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QWorkspace::event(QEvent* e) | ||||
{ | ||||
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*)&e}; | ||||
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 QWorkspace::event(e); | ||||
} | ||||
bool PythonQtShell_QWorkspace::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 QWorkspace::eventFilter(arg__1, arg__2); | ||||
} | ||||
void PythonQtShell_QWorkspace::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; | ||||
} | ||||
} | ||||
QWorkspace::focusInEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QWorkspace::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 QWorkspace::focusNextPrevChild(next); | ||||
} | ||||
void PythonQtShell_QWorkspace::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; | ||||
} | ||||
} | ||||
QWorkspace::focusOutEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QWorkspace::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 QWorkspace::heightForWidth(arg__1); | ||||
} | ||||
void PythonQtShell_QWorkspace::hideEvent(QHideEvent* e) | ||||
{ | ||||
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*)&e}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QWorkspace::hideEvent(e); | ||||
} | ||||
void PythonQtShell_QWorkspace::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; | ||||
} | ||||
} | ||||
QWorkspace::inputMethodEvent(arg__1); | ||||
} | ||||
QVariant PythonQtShell_QWorkspace::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 QWorkspace::inputMethodQuery(arg__1); | ||||
} | ||||
void PythonQtShell_QWorkspace::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; | ||||
} | ||||
} | ||||
QWorkspace::keyPressEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWorkspace::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; | ||||
} | ||||
} | ||||
QWorkspace::keyReleaseEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWorkspace::languageChange() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "languageChange"); | ||||
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; | ||||
} | ||||
} | ||||
QWorkspace::languageChange(); | ||||
} | ||||
void PythonQtShell_QWorkspace::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; | ||||
} | ||||
} | ||||
QWorkspace::leaveEvent(arg__1); | ||||
} | ||||
int PythonQtShell_QWorkspace::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 QWorkspace::metric(arg__1); | ||||
} | ||||
QSize PythonQtShell_QWorkspace::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 QWorkspace::minimumSizeHint(); | ||||
} | ||||
void PythonQtShell_QWorkspace::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; | ||||
} | ||||
} | ||||
QWorkspace::mouseDoubleClickEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWorkspace::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; | ||||
} | ||||
} | ||||
QWorkspace::mouseMoveEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWorkspace::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; | ||||
} | ||||
} | ||||
QWorkspace::mousePressEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWorkspace::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; | ||||
} | ||||
} | ||||
QWorkspace::mouseReleaseEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWorkspace::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; | ||||
} | ||||
} | ||||
QWorkspace::moveEvent(arg__1); | ||||
} | ||||
QPaintEngine* PythonQtShell_QWorkspace::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 QWorkspace::paintEngine(); | ||||
} | ||||
void PythonQtShell_QWorkspace::paintEvent(QPaintEvent* e) | ||||
{ | ||||
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*)&e}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QWorkspace::paintEvent(e); | ||||
} | ||||
void PythonQtShell_QWorkspace::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; | ||||
} | ||||
} | ||||
QWorkspace::resizeEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWorkspace::showEvent(QShowEvent* e) | ||||
{ | ||||
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*)&e}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QWorkspace::showEvent(e); | ||||
} | ||||
void PythonQtShell_QWorkspace::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; | ||||
} | ||||
} | ||||
QWorkspace::tabletEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWorkspace::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; | ||||
} | ||||
} | ||||
QWorkspace::timerEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QWorkspace::wheelEvent(QWheelEvent* e) | ||||
{ | ||||
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*)&e}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QWorkspace::wheelEvent(e); | ||||
} | ||||
QWorkspace* PythonQtWrapper_QWorkspace::new_QWorkspace(QWidget* parent) | ||||
{ | ||||
return new PythonQtShell_QWorkspace(parent); } | ||||
QWidget* PythonQtWrapper_QWorkspace::activeWindow(QWorkspace* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->activeWindow()); | ||||
} | ||||
QWidget* PythonQtWrapper_QWorkspace::addWindow(QWorkspace* theWrappedObject, QWidget* w, Qt::WindowFlags flags) | ||||
{ | ||||
return ( theWrappedObject->addWindow(w, flags)); | ||||
} | ||||
QBrush PythonQtWrapper_QWorkspace::background(QWorkspace* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->background()); | ||||
} | ||||
void PythonQtWrapper_QWorkspace::changeEvent(QWorkspace* theWrappedObject, QEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWorkspace*)theWrappedObject)->promoted_changeEvent(arg__1)); | ||||
} | ||||
void PythonQtWrapper_QWorkspace::childEvent(QWorkspace* theWrappedObject, QChildEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWorkspace*)theWrappedObject)->promoted_childEvent(arg__1)); | ||||
} | ||||
bool PythonQtWrapper_QWorkspace::event(QWorkspace* theWrappedObject, QEvent* e) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QWorkspace*)theWrappedObject)->promoted_event(e)); | ||||
} | ||||
bool PythonQtWrapper_QWorkspace::eventFilter(QWorkspace* theWrappedObject, QObject* arg__1, QEvent* arg__2) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QWorkspace*)theWrappedObject)->promoted_eventFilter(arg__1, arg__2)); | ||||
} | ||||
void PythonQtWrapper_QWorkspace::hideEvent(QWorkspace* theWrappedObject, QHideEvent* e) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWorkspace*)theWrappedObject)->promoted_hideEvent(e)); | ||||
} | ||||
void PythonQtWrapper_QWorkspace::paintEvent(QWorkspace* theWrappedObject, QPaintEvent* e) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWorkspace*)theWrappedObject)->promoted_paintEvent(e)); | ||||
} | ||||
void PythonQtWrapper_QWorkspace::resizeEvent(QWorkspace* theWrappedObject, QResizeEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWorkspace*)theWrappedObject)->promoted_resizeEvent(arg__1)); | ||||
} | ||||
bool PythonQtWrapper_QWorkspace::scrollBarsEnabled(QWorkspace* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->scrollBarsEnabled()); | ||||
} | ||||
void PythonQtWrapper_QWorkspace::setBackground(QWorkspace* theWrappedObject, const QBrush& background) | ||||
{ | ||||
( theWrappedObject->setBackground(background)); | ||||
} | ||||
void PythonQtWrapper_QWorkspace::setScrollBarsEnabled(QWorkspace* theWrappedObject, bool enable) | ||||
{ | ||||
( theWrappedObject->setScrollBarsEnabled(enable)); | ||||
} | ||||
void PythonQtWrapper_QWorkspace::showEvent(QWorkspace* theWrappedObject, QShowEvent* e) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWorkspace*)theWrappedObject)->promoted_showEvent(e)); | ||||
} | ||||
QSize PythonQtWrapper_QWorkspace::sizeHint(QWorkspace* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->sizeHint()); | ||||
} | ||||
void PythonQtWrapper_QWorkspace::wheelEvent(QWorkspace* theWrappedObject, QWheelEvent* e) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QWorkspace*)theWrappedObject)->promoted_wheelEvent(e)); | ||||
} | ||||
QList<QWidget* > PythonQtWrapper_QWorkspace::windowList(QWorkspace* theWrappedObject, QWorkspace::WindowOrder order) const | ||||
{ | ||||
return ( theWrappedObject->windowList(order)); | ||||
} | ||||