|
|
#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));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
