|
|
#include "com_trolltech_qt_core1.h"
|
|
|
#include <PythonQtConversion.h>
|
|
|
#include <PythonQtMethodInfo.h>
|
|
|
#include <PythonQtSignalReceiver.h>
|
|
|
#include <QStringList>
|
|
|
#include <QTextCodec>
|
|
|
#include <QVarLengthArray>
|
|
|
#include <QVariant>
|
|
|
#include <qabstractanimation.h>
|
|
|
#include <qabstractitemmodel.h>
|
|
|
#include <qabstractstate.h>
|
|
|
#include <qabstracttransition.h>
|
|
|
#include <qanimationgroup.h>
|
|
|
#include <qbytearray.h>
|
|
|
#include <qcoreevent.h>
|
|
|
#include <qeasingcurve.h>
|
|
|
#include <qfile.h>
|
|
|
#include <qiodevice.h>
|
|
|
#include <qlist.h>
|
|
|
#include <qlocale.h>
|
|
|
#include <qmutex.h>
|
|
|
#include <qobject.h>
|
|
|
#include <qpair.h>
|
|
|
#include <qparallelanimationgroup.h>
|
|
|
#include <qpauseanimation.h>
|
|
|
#include <qprocess.h>
|
|
|
#include <qpropertyanimation.h>
|
|
|
#include <qreadwritelock.h>
|
|
|
#include <qrunnable.h>
|
|
|
#include <qsemaphore.h>
|
|
|
#include <qsequentialanimationgroup.h>
|
|
|
#include <qsettings.h>
|
|
|
#include <qsignalmapper.h>
|
|
|
#include <qsignaltransition.h>
|
|
|
#include <qsocketnotifier.h>
|
|
|
#include <qstate.h>
|
|
|
#include <qstatemachine.h>
|
|
|
#include <qstringlist.h>
|
|
|
#include <qstringmatcher.h>
|
|
|
#include <qsystemsemaphore.h>
|
|
|
#include <qtemporaryfile.h>
|
|
|
#include <qtextboundaryfinder.h>
|
|
|
#include <qtextcodec.h>
|
|
|
#include <qtextstream.h>
|
|
|
#include <qthreadpool.h>
|
|
|
#include <qtimeline.h>
|
|
|
#include <qvector.h>
|
|
|
|
|
|
QModelIndex* PythonQtWrapper_QModelIndex::new_QModelIndex()
|
|
|
{
|
|
|
return new QModelIndex(); }
|
|
|
|
|
|
QModelIndex PythonQtWrapper_QModelIndex::child(QModelIndex* theWrappedObject, int row, int column) const
|
|
|
{
|
|
|
return ( theWrappedObject->child(row, column));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QModelIndex::column(QModelIndex* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->column());
|
|
|
}
|
|
|
|
|
|
QVariant PythonQtWrapper_QModelIndex::data(QModelIndex* theWrappedObject, int role) const
|
|
|
{
|
|
|
return ( theWrappedObject->data(role));
|
|
|
}
|
|
|
|
|
|
Qt::ItemFlags PythonQtWrapper_QModelIndex::flags(QModelIndex* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->flags());
|
|
|
}
|
|
|
|
|
|
quintptr PythonQtWrapper_QModelIndex::internalId(QModelIndex* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->internalId());
|
|
|
}
|
|
|
|
|
|
void* PythonQtWrapper_QModelIndex::internalPointer(QModelIndex* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->internalPointer());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QModelIndex::isValid(QModelIndex* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isValid());
|
|
|
}
|
|
|
|
|
|
const QAbstractItemModel* PythonQtWrapper_QModelIndex::model(QModelIndex* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->model());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QModelIndex::__ne__(QModelIndex* theWrappedObject, const QModelIndex& other) const
|
|
|
{
|
|
|
return ( (*theWrappedObject)!= other);
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QModelIndex::__lt__(QModelIndex* theWrappedObject, const QModelIndex& other) const
|
|
|
{
|
|
|
return ( (*theWrappedObject)< other);
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QModelIndex::__eq__(QModelIndex* theWrappedObject, const QModelIndex& other) const
|
|
|
{
|
|
|
return ( (*theWrappedObject)== other);
|
|
|
}
|
|
|
|
|
|
QModelIndex PythonQtWrapper_QModelIndex::parent(QModelIndex* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->parent());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QModelIndex::row(QModelIndex* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->row());
|
|
|
}
|
|
|
|
|
|
QModelIndex PythonQtWrapper_QModelIndex::sibling(QModelIndex* theWrappedObject, int row, int column) const
|
|
|
{
|
|
|
return ( theWrappedObject->sibling(row, column));
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QModelIndex::py_toString(QModelIndex* obj) {
|
|
|
QString result;
|
|
|
QDebug d(&result);
|
|
|
d << *obj;
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QMutex* PythonQtWrapper_QMutex::new_QMutex(QMutex::RecursionMode mode)
|
|
|
{
|
|
|
return new QMutex(mode); }
|
|
|
|
|
|
void PythonQtWrapper_QMutex::lock(QMutex* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->lock());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QMutex::tryLock(QMutex* theWrappedObject, int timeout)
|
|
|
{
|
|
|
return ( theWrappedObject->tryLock(timeout));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QMutex::unlock(QMutex* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->unlock());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QObject::~PythonQtShell_QObject() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QObject::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;
|
|
|
}
|
|
|
}
|
|
|
QObject::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QObject::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;
|
|
|
}
|
|
|
}
|
|
|
QObject::customEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QObject::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 QObject::event(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QObject::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 QObject::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
void PythonQtShell_QObject::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;
|
|
|
}
|
|
|
}
|
|
|
QObject::timerEvent(arg__1);
|
|
|
}
|
|
|
QObject* PythonQtWrapper_QObject::new_QObject(QObject* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QObject(parent); }
|
|
|
|
|
|
bool PythonQtWrapper_QObject::blockSignals(QObject* theWrappedObject, bool b)
|
|
|
{
|
|
|
return ( theWrappedObject->blockSignals(b));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QObject::childEvent(QObject* theWrappedObject, QChildEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QObject*)theWrappedObject)->promoted_childEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
const QList<QObject* >* PythonQtWrapper_QObject::children(QObject* theWrappedObject) const
|
|
|
{
|
|
|
return &( theWrappedObject->children());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QObject::customEvent(QObject* theWrappedObject, QEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QObject*)theWrappedObject)->promoted_customEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QObject::dumpObjectInfo(QObject* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->dumpObjectInfo());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QObject::dumpObjectTree(QObject* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->dumpObjectTree());
|
|
|
}
|
|
|
|
|
|
QList<QByteArray > PythonQtWrapper_QObject::dynamicPropertyNames(QObject* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->dynamicPropertyNames());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QObject::event(QObject* theWrappedObject, QEvent* arg__1)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QObject*)theWrappedObject)->promoted_event(arg__1));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QObject::eventFilter(QObject* theWrappedObject, QObject* arg__1, QEvent* arg__2)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QObject*)theWrappedObject)->promoted_eventFilter(arg__1, arg__2));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QObject::inherits(QObject* theWrappedObject, const char* classname) const
|
|
|
{
|
|
|
return ( theWrappedObject->inherits(classname));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QObject::installEventFilter(QObject* theWrappedObject, QObject* arg__1)
|
|
|
{
|
|
|
( theWrappedObject->installEventFilter(arg__1));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QObject::isWidgetType(QObject* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isWidgetType());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QObject::isWindowType(QObject* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isWindowType());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QObject::killTimer(QObject* theWrappedObject, int id)
|
|
|
{
|
|
|
( theWrappedObject->killTimer(id));
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QObject::objectName(QObject* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->objectName());
|
|
|
}
|
|
|
|
|
|
QObject* PythonQtWrapper_QObject::parent(QObject* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->parent());
|
|
|
}
|
|
|
|
|
|
QVariant PythonQtWrapper_QObject::property(QObject* theWrappedObject, const char* name) const
|
|
|
{
|
|
|
return ( theWrappedObject->property(name));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QObject::removeEventFilter(QObject* theWrappedObject, QObject* arg__1)
|
|
|
{
|
|
|
( theWrappedObject->removeEventFilter(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QObject::setObjectName(QObject* theWrappedObject, const QString& name)
|
|
|
{
|
|
|
( theWrappedObject->setObjectName(name));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QObject::setParent(QObject* theWrappedObject, QObject* arg__1)
|
|
|
{
|
|
|
( theWrappedObject->setParent(arg__1));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QObject::setProperty(QObject* theWrappedObject, const char* name, const QVariant& value)
|
|
|
{
|
|
|
return ( theWrappedObject->setProperty(name, value));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QObject::signalsBlocked(QObject* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->signalsBlocked());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QObject::startTimer(QObject* theWrappedObject, int interval, Qt::TimerType timerType)
|
|
|
{
|
|
|
return ( theWrappedObject->startTimer(interval, timerType));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QObject::timerEvent(QObject* theWrappedObject, QTimerEvent* arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QObject*)theWrappedObject)->promoted_timerEvent(arg__1));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QParallelAnimationGroup::~PythonQtShell_QParallelAnimationGroup() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QParallelAnimationGroup::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;
|
|
|
}
|
|
|
}
|
|
|
QParallelAnimationGroup::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QParallelAnimationGroup::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;
|
|
|
}
|
|
|
}
|
|
|
QParallelAnimationGroup::customEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QParallelAnimationGroup::duration() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "duration");
|
|
|
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("duration", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QParallelAnimationGroup::duration();
|
|
|
}
|
|
|
bool PythonQtShell_QParallelAnimationGroup::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 QParallelAnimationGroup::event(event);
|
|
|
}
|
|
|
bool PythonQtShell_QParallelAnimationGroup::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 QParallelAnimationGroup::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
void PythonQtShell_QParallelAnimationGroup::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;
|
|
|
}
|
|
|
}
|
|
|
QParallelAnimationGroup::timerEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QParallelAnimationGroup::updateCurrentTime(int currentTime)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateCurrentTime");
|
|
|
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*)¤tTime};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QParallelAnimationGroup::updateCurrentTime(currentTime);
|
|
|
}
|
|
|
void PythonQtShell_QParallelAnimationGroup::updateDirection(QAbstractAnimation::Direction direction)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateDirection");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QAbstractAnimation::Direction"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&direction};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QParallelAnimationGroup::updateDirection(direction);
|
|
|
}
|
|
|
void PythonQtShell_QParallelAnimationGroup::updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateState");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QAbstractAnimation::State" , "QAbstractAnimation::State"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
void* args[3] = {NULL, (void*)&newState, (void*)&oldState};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QParallelAnimationGroup::updateState(newState, oldState);
|
|
|
}
|
|
|
QParallelAnimationGroup* PythonQtWrapper_QParallelAnimationGroup::new_QParallelAnimationGroup(QObject* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QParallelAnimationGroup(parent); }
|
|
|
|
|
|
int PythonQtWrapper_QParallelAnimationGroup::duration(QParallelAnimationGroup* theWrappedObject) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QParallelAnimationGroup*)theWrappedObject)->promoted_duration());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QParallelAnimationGroup::event(QParallelAnimationGroup* theWrappedObject, QEvent* event)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QParallelAnimationGroup*)theWrappedObject)->promoted_event(event));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QParallelAnimationGroup::updateCurrentTime(QParallelAnimationGroup* theWrappedObject, int currentTime)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QParallelAnimationGroup*)theWrappedObject)->promoted_updateCurrentTime(currentTime));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QParallelAnimationGroup::updateDirection(QParallelAnimationGroup* theWrappedObject, QAbstractAnimation::Direction direction)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QParallelAnimationGroup*)theWrappedObject)->promoted_updateDirection(direction));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QParallelAnimationGroup::updateState(QParallelAnimationGroup* theWrappedObject, QAbstractAnimation::State newState, QAbstractAnimation::State oldState)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QParallelAnimationGroup*)theWrappedObject)->promoted_updateState(newState, oldState));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QPauseAnimation::~PythonQtShell_QPauseAnimation() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QPauseAnimation::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;
|
|
|
}
|
|
|
}
|
|
|
QPauseAnimation::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QPauseAnimation::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;
|
|
|
}
|
|
|
}
|
|
|
QPauseAnimation::customEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QPauseAnimation::duration() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "duration");
|
|
|
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("duration", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QPauseAnimation::duration();
|
|
|
}
|
|
|
bool PythonQtShell_QPauseAnimation::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 QPauseAnimation::event(e);
|
|
|
}
|
|
|
bool PythonQtShell_QPauseAnimation::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 QPauseAnimation::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
void PythonQtShell_QPauseAnimation::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;
|
|
|
}
|
|
|
}
|
|
|
QPauseAnimation::timerEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QPauseAnimation::updateCurrentTime(int arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateCurrentTime");
|
|
|
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*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPauseAnimation::updateCurrentTime(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QPauseAnimation::updateDirection(QAbstractAnimation::Direction direction)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateDirection");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QAbstractAnimation::Direction"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&direction};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPauseAnimation::updateDirection(direction);
|
|
|
}
|
|
|
void PythonQtShell_QPauseAnimation::updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateState");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QAbstractAnimation::State" , "QAbstractAnimation::State"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
void* args[3] = {NULL, (void*)&newState, (void*)&oldState};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPauseAnimation::updateState(newState, oldState);
|
|
|
}
|
|
|
QPauseAnimation* PythonQtWrapper_QPauseAnimation::new_QPauseAnimation(QObject* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QPauseAnimation(parent); }
|
|
|
|
|
|
QPauseAnimation* PythonQtWrapper_QPauseAnimation::new_QPauseAnimation(int msecs, QObject* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QPauseAnimation(msecs, parent); }
|
|
|
|
|
|
int PythonQtWrapper_QPauseAnimation::duration(QPauseAnimation* theWrappedObject) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QPauseAnimation*)theWrappedObject)->promoted_duration());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QPauseAnimation::event(QPauseAnimation* theWrappedObject, QEvent* e)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QPauseAnimation*)theWrappedObject)->promoted_event(e));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPauseAnimation::setDuration(QPauseAnimation* theWrappedObject, int msecs)
|
|
|
{
|
|
|
( theWrappedObject->setDuration(msecs));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPauseAnimation::updateCurrentTime(QPauseAnimation* theWrappedObject, int arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QPauseAnimation*)theWrappedObject)->promoted_updateCurrentTime(arg__1));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QProcess::~PythonQtShell_QProcess() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
bool PythonQtShell_QProcess::atEnd() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "atEnd");
|
|
|
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("atEnd", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QProcess::atEnd();
|
|
|
}
|
|
|
qint64 PythonQtShell_QProcess::bytesAvailable() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "bytesAvailable");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"qint64"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
qint64 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("bytesAvailable", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((qint64*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QProcess::bytesAvailable();
|
|
|
}
|
|
|
qint64 PythonQtShell_QProcess::bytesToWrite() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "bytesToWrite");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"qint64"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
qint64 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("bytesToWrite", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((qint64*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QProcess::bytesToWrite();
|
|
|
}
|
|
|
bool PythonQtShell_QProcess::canReadLine() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "canReadLine");
|
|
|
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("canReadLine", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QProcess::canReadLine();
|
|
|
}
|
|
|
void PythonQtShell_QProcess::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;
|
|
|
}
|
|
|
}
|
|
|
QProcess::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QProcess::close()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "close");
|
|
|
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;
|
|
|
}
|
|
|
}
|
|
|
QProcess::close();
|
|
|
}
|
|
|
void PythonQtShell_QProcess::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;
|
|
|
}
|
|
|
}
|
|
|
QProcess::customEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QProcess::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 QProcess::event(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QProcess::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 QProcess::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
bool PythonQtShell_QProcess::isSequential() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isSequential");
|
|
|
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("isSequential", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QProcess::isSequential();
|
|
|
}
|
|
|
bool PythonQtShell_QProcess::open(QIODevice::OpenMode mode)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "open");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "QIODevice::OpenMode"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&mode};
|
|
|
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("open", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QProcess::open(mode);
|
|
|
}
|
|
|
qint64 PythonQtShell_QProcess::pos() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "pos");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"qint64"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
qint64 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("pos", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((qint64*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QProcess::pos();
|
|
|
}
|
|
|
qint64 PythonQtShell_QProcess::readData(char* data, qint64 maxlen)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "readData");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"qint64" , "char*" , "qint64"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
qint64 returnValue;
|
|
|
void* args[3] = {NULL, (void*)&data, (void*)&maxlen};
|
|
|
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("readData", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((qint64*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QProcess::readData(data, maxlen);
|
|
|
}
|
|
|
qint64 PythonQtShell_QProcess::readLineData(char* data, qint64 maxlen)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "readLineData");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"qint64" , "char*" , "qint64"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
qint64 returnValue;
|
|
|
void* args[3] = {NULL, (void*)&data, (void*)&maxlen};
|
|
|
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("readLineData", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((qint64*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QProcess::readLineData(data, maxlen);
|
|
|
}
|
|
|
bool PythonQtShell_QProcess::reset()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reset");
|
|
|
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("reset", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QProcess::reset();
|
|
|
}
|
|
|
bool PythonQtShell_QProcess::seek(qint64 pos)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "seek");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "qint64"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&pos};
|
|
|
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("seek", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QProcess::seek(pos);
|
|
|
}
|
|
|
void PythonQtShell_QProcess::setupChildProcess()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setupChildProcess");
|
|
|
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;
|
|
|
}
|
|
|
}
|
|
|
QProcess::setupChildProcess();
|
|
|
}
|
|
|
qint64 PythonQtShell_QProcess::size() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "size");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"qint64"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
qint64 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("size", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((qint64*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QProcess::size();
|
|
|
}
|
|
|
void PythonQtShell_QProcess::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;
|
|
|
}
|
|
|
}
|
|
|
QProcess::timerEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QProcess::waitForBytesWritten(int msecs)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "waitForBytesWritten");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&msecs};
|
|
|
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("waitForBytesWritten", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QProcess::waitForBytesWritten(msecs);
|
|
|
}
|
|
|
bool PythonQtShell_QProcess::waitForReadyRead(int msecs)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "waitForReadyRead");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"bool" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
bool returnValue;
|
|
|
void* args[2] = {NULL, (void*)&msecs};
|
|
|
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("waitForReadyRead", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QProcess::waitForReadyRead(msecs);
|
|
|
}
|
|
|
qint64 PythonQtShell_QProcess::writeData(const char* data, qint64 len)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "writeData");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"qint64" , "const char*" , "qint64"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
qint64 returnValue;
|
|
|
void* args[3] = {NULL, (void*)&data, (void*)&len};
|
|
|
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("writeData", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((qint64*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QProcess::writeData(data, len);
|
|
|
}
|
|
|
QProcess* PythonQtWrapper_QProcess::new_QProcess(QObject* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QProcess(parent); }
|
|
|
|
|
|
QStringList PythonQtWrapper_QProcess::arguments(QProcess* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->arguments());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QProcess::atEnd(QProcess* theWrappedObject) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QProcess*)theWrappedObject)->promoted_atEnd());
|
|
|
}
|
|
|
|
|
|
qint64 PythonQtWrapper_QProcess::bytesAvailable(QProcess* theWrappedObject) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QProcess*)theWrappedObject)->promoted_bytesAvailable());
|
|
|
}
|
|
|
|
|
|
qint64 PythonQtWrapper_QProcess::bytesToWrite(QProcess* theWrappedObject) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QProcess*)theWrappedObject)->promoted_bytesToWrite());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QProcess::canReadLine(QProcess* theWrappedObject) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QProcess*)theWrappedObject)->promoted_canReadLine());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QProcess::close(QProcess* theWrappedObject)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QProcess*)theWrappedObject)->promoted_close());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QProcess::closeReadChannel(QProcess* theWrappedObject, QProcess::ProcessChannel channel)
|
|
|
{
|
|
|
( theWrappedObject->closeReadChannel(channel));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QProcess::closeWriteChannel(QProcess* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->closeWriteChannel());
|
|
|
}
|
|
|
|
|
|
QStringList PythonQtWrapper_QProcess::environment(QProcess* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->environment());
|
|
|
}
|
|
|
|
|
|
QProcess::ProcessError PythonQtWrapper_QProcess::error(QProcess* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->error());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QProcess::static_QProcess_execute(const QString& program)
|
|
|
{
|
|
|
return (QProcess::execute(program));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QProcess::static_QProcess_execute(const QString& program, const QStringList& arguments)
|
|
|
{
|
|
|
return (QProcess::execute(program, arguments));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QProcess::exitCode(QProcess* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->exitCode());
|
|
|
}
|
|
|
|
|
|
QProcess::ExitStatus PythonQtWrapper_QProcess::exitStatus(QProcess* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->exitStatus());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QProcess::isSequential(QProcess* theWrappedObject) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QProcess*)theWrappedObject)->promoted_isSequential());
|
|
|
}
|
|
|
|
|
|
QProcess::ProcessChannelMode PythonQtWrapper_QProcess::processChannelMode(QProcess* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->processChannelMode());
|
|
|
}
|
|
|
|
|
|
QProcessEnvironment PythonQtWrapper_QProcess::processEnvironment(QProcess* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->processEnvironment());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QProcess::program(QProcess* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->program());
|
|
|
}
|
|
|
|
|
|
QByteArray PythonQtWrapper_QProcess::readAllStandardError(QProcess* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->readAllStandardError());
|
|
|
}
|
|
|
|
|
|
QByteArray PythonQtWrapper_QProcess::readAllStandardOutput(QProcess* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->readAllStandardOutput());
|
|
|
}
|
|
|
|
|
|
QProcess::ProcessChannel PythonQtWrapper_QProcess::readChannel(QProcess* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->readChannel());
|
|
|
}
|
|
|
|
|
|
qint64 PythonQtWrapper_QProcess::readData(QProcess* theWrappedObject, char* data, qint64 maxlen)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QProcess*)theWrappedObject)->promoted_readData(data, maxlen));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QProcess::setEnvironment(QProcess* theWrappedObject, const QStringList& environment)
|
|
|
{
|
|
|
( theWrappedObject->setEnvironment(environment));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QProcess::setProcessChannelMode(QProcess* theWrappedObject, QProcess::ProcessChannelMode mode)
|
|
|
{
|
|
|
( theWrappedObject->setProcessChannelMode(mode));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QProcess::setProcessEnvironment(QProcess* theWrappedObject, const QProcessEnvironment& environment)
|
|
|
{
|
|
|
( theWrappedObject->setProcessEnvironment(environment));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QProcess::setReadChannel(QProcess* theWrappedObject, QProcess::ProcessChannel channel)
|
|
|
{
|
|
|
( theWrappedObject->setReadChannel(channel));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QProcess::setStandardErrorFile(QProcess* theWrappedObject, const QString& fileName, QIODevice::OpenMode mode)
|
|
|
{
|
|
|
( theWrappedObject->setStandardErrorFile(fileName, mode));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QProcess::setStandardInputFile(QProcess* theWrappedObject, const QString& fileName)
|
|
|
{
|
|
|
( theWrappedObject->setStandardInputFile(fileName));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QProcess::setStandardOutputFile(QProcess* theWrappedObject, const QString& fileName, QIODevice::OpenMode mode)
|
|
|
{
|
|
|
( theWrappedObject->setStandardOutputFile(fileName, mode));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QProcess::setStandardOutputProcess(QProcess* theWrappedObject, QProcess* destination)
|
|
|
{
|
|
|
( theWrappedObject->setStandardOutputProcess(destination));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QProcess::setWorkingDirectory(QProcess* theWrappedObject, const QString& dir)
|
|
|
{
|
|
|
( theWrappedObject->setWorkingDirectory(dir));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QProcess::setupChildProcess(QProcess* theWrappedObject)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QProcess*)theWrappedObject)->promoted_setupChildProcess());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QProcess::start(QProcess* theWrappedObject, const QString& command, QIODevice::OpenMode mode)
|
|
|
{
|
|
|
( theWrappedObject->start(command, mode));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QProcess::start(QProcess* theWrappedObject, const QString& program, const QStringList& arguments, QIODevice::OpenMode mode)
|
|
|
{
|
|
|
( theWrappedObject->start(program, arguments, mode));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QProcess::static_QProcess_startDetached(const QString& program)
|
|
|
{
|
|
|
return (QProcess::startDetached(program));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QProcess::static_QProcess_startDetached(const QString& program, const QStringList& arguments)
|
|
|
{
|
|
|
return (QProcess::startDetached(program, arguments));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QProcess::static_QProcess_startDetached(const QString& program, const QStringList& arguments, const QString& workingDirectory, qint64* pid)
|
|
|
{
|
|
|
return (QProcess::startDetached(program, arguments, workingDirectory, pid));
|
|
|
}
|
|
|
|
|
|
QProcess::ProcessState PythonQtWrapper_QProcess::state(QProcess* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->state());
|
|
|
}
|
|
|
|
|
|
QStringList PythonQtWrapper_QProcess::static_QProcess_systemEnvironment()
|
|
|
{
|
|
|
return (QProcess::systemEnvironment());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QProcess::waitForBytesWritten(QProcess* theWrappedObject, int msecs)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QProcess*)theWrappedObject)->promoted_waitForBytesWritten(msecs));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QProcess::waitForFinished(QProcess* theWrappedObject, int msecs)
|
|
|
{
|
|
|
return ( theWrappedObject->waitForFinished(msecs));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QProcess::waitForReadyRead(QProcess* theWrappedObject, int msecs)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QProcess*)theWrappedObject)->promoted_waitForReadyRead(msecs));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QProcess::waitForStarted(QProcess* theWrappedObject, int msecs)
|
|
|
{
|
|
|
return ( theWrappedObject->waitForStarted(msecs));
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QProcess::workingDirectory(QProcess* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->workingDirectory());
|
|
|
}
|
|
|
|
|
|
qint64 PythonQtWrapper_QProcess::writeData(QProcess* theWrappedObject, const char* data, qint64 len)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QProcess*)theWrappedObject)->promoted_writeData(data, len));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QProcessEnvironment* PythonQtWrapper_QProcessEnvironment::new_QProcessEnvironment()
|
|
|
{
|
|
|
return new QProcessEnvironment(); }
|
|
|
|
|
|
QProcessEnvironment* PythonQtWrapper_QProcessEnvironment::new_QProcessEnvironment(const QProcessEnvironment& other)
|
|
|
{
|
|
|
return new QProcessEnvironment(other); }
|
|
|
|
|
|
void PythonQtWrapper_QProcessEnvironment::clear(QProcessEnvironment* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->clear());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QProcessEnvironment::contains(QProcessEnvironment* theWrappedObject, const QString& name) const
|
|
|
{
|
|
|
return ( theWrappedObject->contains(name));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QProcessEnvironment::insert(QProcessEnvironment* theWrappedObject, const QProcessEnvironment& e)
|
|
|
{
|
|
|
( theWrappedObject->insert(e));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QProcessEnvironment::insert(QProcessEnvironment* theWrappedObject, const QString& name, const QString& value)
|
|
|
{
|
|
|
( theWrappedObject->insert(name, value));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QProcessEnvironment::isEmpty(QProcessEnvironment* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isEmpty());
|
|
|
}
|
|
|
|
|
|
QStringList PythonQtWrapper_QProcessEnvironment::keys(QProcessEnvironment* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->keys());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QProcessEnvironment::__ne__(QProcessEnvironment* theWrappedObject, const QProcessEnvironment& other) const
|
|
|
{
|
|
|
return ( (*theWrappedObject)!= other);
|
|
|
}
|
|
|
|
|
|
QProcessEnvironment* PythonQtWrapper_QProcessEnvironment::operator_assign(QProcessEnvironment* theWrappedObject, const QProcessEnvironment& other)
|
|
|
{
|
|
|
return &( (*theWrappedObject)= other);
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QProcessEnvironment::__eq__(QProcessEnvironment* theWrappedObject, const QProcessEnvironment& other) const
|
|
|
{
|
|
|
return ( (*theWrappedObject)== other);
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QProcessEnvironment::remove(QProcessEnvironment* theWrappedObject, const QString& name)
|
|
|
{
|
|
|
( theWrappedObject->remove(name));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QProcessEnvironment::swap(QProcessEnvironment* theWrappedObject, QProcessEnvironment& other)
|
|
|
{
|
|
|
( theWrappedObject->swap(other));
|
|
|
}
|
|
|
|
|
|
QProcessEnvironment PythonQtWrapper_QProcessEnvironment::static_QProcessEnvironment_systemEnvironment()
|
|
|
{
|
|
|
return (QProcessEnvironment::systemEnvironment());
|
|
|
}
|
|
|
|
|
|
QStringList PythonQtWrapper_QProcessEnvironment::toStringList(QProcessEnvironment* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->toStringList());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QProcessEnvironment::value(QProcessEnvironment* theWrappedObject, const QString& name, const QString& defaultValue) const
|
|
|
{
|
|
|
return ( theWrappedObject->value(name, defaultValue));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QPropertyAnimation::~PythonQtShell_QPropertyAnimation() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QPropertyAnimation::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;
|
|
|
}
|
|
|
}
|
|
|
QPropertyAnimation::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QPropertyAnimation::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;
|
|
|
}
|
|
|
}
|
|
|
QPropertyAnimation::customEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QPropertyAnimation::duration() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "duration");
|
|
|
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("duration", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QPropertyAnimation::duration();
|
|
|
}
|
|
|
bool PythonQtShell_QPropertyAnimation::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 QPropertyAnimation::event(event);
|
|
|
}
|
|
|
bool PythonQtShell_QPropertyAnimation::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 QPropertyAnimation::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
QVariant PythonQtShell_QPropertyAnimation::interpolated(const QVariant& from, const QVariant& to, qreal progress) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "interpolated");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QVariant" , "const QVariant&" , "const QVariant&" , "qreal"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
|
|
|
QVariant returnValue;
|
|
|
void* args[4] = {NULL, (void*)&from, (void*)&to, (void*)&progress};
|
|
|
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("interpolated", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QVariant*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QPropertyAnimation::interpolated(from, to, progress);
|
|
|
}
|
|
|
void PythonQtShell_QPropertyAnimation::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;
|
|
|
}
|
|
|
}
|
|
|
QPropertyAnimation::timerEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QPropertyAnimation::updateCurrentTime(int arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateCurrentTime");
|
|
|
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*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPropertyAnimation::updateCurrentTime(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QPropertyAnimation::updateCurrentValue(const QVariant& value)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateCurrentValue");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "const QVariant&"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&value};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPropertyAnimation::updateCurrentValue(value);
|
|
|
}
|
|
|
void PythonQtShell_QPropertyAnimation::updateDirection(QAbstractAnimation::Direction direction)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateDirection");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QAbstractAnimation::Direction"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&direction};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPropertyAnimation::updateDirection(direction);
|
|
|
}
|
|
|
void PythonQtShell_QPropertyAnimation::updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateState");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QAbstractAnimation::State" , "QAbstractAnimation::State"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
void* args[3] = {NULL, (void*)&newState, (void*)&oldState};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QPropertyAnimation::updateState(newState, oldState);
|
|
|
}
|
|
|
QPropertyAnimation* PythonQtWrapper_QPropertyAnimation::new_QPropertyAnimation(QObject* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QPropertyAnimation(parent); }
|
|
|
|
|
|
QPropertyAnimation* PythonQtWrapper_QPropertyAnimation::new_QPropertyAnimation(QObject* target, const QByteArray& propertyName, QObject* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QPropertyAnimation(target, propertyName, parent); }
|
|
|
|
|
|
bool PythonQtWrapper_QPropertyAnimation::event(QPropertyAnimation* theWrappedObject, QEvent* event)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QPropertyAnimation*)theWrappedObject)->promoted_event(event));
|
|
|
}
|
|
|
|
|
|
QByteArray PythonQtWrapper_QPropertyAnimation::propertyName(QPropertyAnimation* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->propertyName());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPropertyAnimation::setPropertyName(QPropertyAnimation* theWrappedObject, const QByteArray& propertyName)
|
|
|
{
|
|
|
( theWrappedObject->setPropertyName(propertyName));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPropertyAnimation::setTargetObject(QPropertyAnimation* theWrappedObject, QObject* target)
|
|
|
{
|
|
|
( theWrappedObject->setTargetObject(target));
|
|
|
}
|
|
|
|
|
|
QObject* PythonQtWrapper_QPropertyAnimation::targetObject(QPropertyAnimation* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->targetObject());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPropertyAnimation::updateCurrentValue(QPropertyAnimation* theWrappedObject, const QVariant& value)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QPropertyAnimation*)theWrappedObject)->promoted_updateCurrentValue(value));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QPropertyAnimation::updateState(QPropertyAnimation* theWrappedObject, QAbstractAnimation::State newState, QAbstractAnimation::State oldState)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QPropertyAnimation*)theWrappedObject)->promoted_updateState(newState, oldState));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QReadWriteLock* PythonQtWrapper_QReadWriteLock::new_QReadWriteLock(QReadWriteLock::RecursionMode recursionMode)
|
|
|
{
|
|
|
return new QReadWriteLock(recursionMode); }
|
|
|
|
|
|
void PythonQtWrapper_QReadWriteLock::lockForRead(QReadWriteLock* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->lockForRead());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QReadWriteLock::lockForWrite(QReadWriteLock* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->lockForWrite());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QReadWriteLock::tryLockForRead(QReadWriteLock* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->tryLockForRead());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QReadWriteLock::tryLockForRead(QReadWriteLock* theWrappedObject, int timeout)
|
|
|
{
|
|
|
return ( theWrappedObject->tryLockForRead(timeout));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QReadWriteLock::tryLockForWrite(QReadWriteLock* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->tryLockForWrite());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QReadWriteLock::tryLockForWrite(QReadWriteLock* theWrappedObject, int timeout)
|
|
|
{
|
|
|
return ( theWrappedObject->tryLockForWrite(timeout));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QReadWriteLock::unlock(QReadWriteLock* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->unlock());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QRunnable::~PythonQtShell_QRunnable() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QRunnable::run()
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "run");
|
|
|
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;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
}
|
|
|
QRunnable* PythonQtWrapper_QRunnable::new_QRunnable()
|
|
|
{
|
|
|
return new PythonQtShell_QRunnable(); }
|
|
|
|
|
|
bool PythonQtWrapper_QRunnable::autoDelete(QRunnable* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->autoDelete());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QRunnable::setAutoDelete(QRunnable* theWrappedObject, bool _autoDelete)
|
|
|
{
|
|
|
( theWrappedObject->setAutoDelete(_autoDelete));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QSemaphore* PythonQtWrapper_QSemaphore::new_QSemaphore(int n)
|
|
|
{
|
|
|
return new QSemaphore(n); }
|
|
|
|
|
|
void PythonQtWrapper_QSemaphore::acquire(QSemaphore* theWrappedObject, int n)
|
|
|
{
|
|
|
( theWrappedObject->acquire(n));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QSemaphore::available(QSemaphore* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->available());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QSemaphore::release(QSemaphore* theWrappedObject, int n)
|
|
|
{
|
|
|
( theWrappedObject->release(n));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QSemaphore::tryAcquire(QSemaphore* theWrappedObject, int n)
|
|
|
{
|
|
|
return ( theWrappedObject->tryAcquire(n));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QSemaphore::tryAcquire(QSemaphore* theWrappedObject, int n, int timeout)
|
|
|
{
|
|
|
return ( theWrappedObject->tryAcquire(n, timeout));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QSequentialAnimationGroup::~PythonQtShell_QSequentialAnimationGroup() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QSequentialAnimationGroup::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;
|
|
|
}
|
|
|
}
|
|
|
QSequentialAnimationGroup::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QSequentialAnimationGroup::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;
|
|
|
}
|
|
|
}
|
|
|
QSequentialAnimationGroup::customEvent(arg__1);
|
|
|
}
|
|
|
int PythonQtShell_QSequentialAnimationGroup::duration() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "duration");
|
|
|
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("duration", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QSequentialAnimationGroup::duration();
|
|
|
}
|
|
|
bool PythonQtShell_QSequentialAnimationGroup::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 QSequentialAnimationGroup::event(event);
|
|
|
}
|
|
|
bool PythonQtShell_QSequentialAnimationGroup::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 QSequentialAnimationGroup::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
void PythonQtShell_QSequentialAnimationGroup::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;
|
|
|
}
|
|
|
}
|
|
|
QSequentialAnimationGroup::timerEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QSequentialAnimationGroup::updateCurrentTime(int arg__1)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateCurrentTime");
|
|
|
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*)&arg__1};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QSequentialAnimationGroup::updateCurrentTime(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QSequentialAnimationGroup::updateDirection(QAbstractAnimation::Direction direction)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateDirection");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QAbstractAnimation::Direction"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
void* args[2] = {NULL, (void*)&direction};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QSequentialAnimationGroup::updateDirection(direction);
|
|
|
}
|
|
|
void PythonQtShell_QSequentialAnimationGroup::updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateState");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"" , "QAbstractAnimation::State" , "QAbstractAnimation::State"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
|
|
void* args[3] = {NULL, (void*)&newState, (void*)&oldState};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QSequentialAnimationGroup::updateState(newState, oldState);
|
|
|
}
|
|
|
QSequentialAnimationGroup* PythonQtWrapper_QSequentialAnimationGroup::new_QSequentialAnimationGroup(QObject* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QSequentialAnimationGroup(parent); }
|
|
|
|
|
|
QPauseAnimation* PythonQtWrapper_QSequentialAnimationGroup::addPause(QSequentialAnimationGroup* theWrappedObject, int msecs)
|
|
|
{
|
|
|
return ( theWrappedObject->addPause(msecs));
|
|
|
}
|
|
|
|
|
|
QAbstractAnimation* PythonQtWrapper_QSequentialAnimationGroup::currentAnimation(QSequentialAnimationGroup* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->currentAnimation());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QSequentialAnimationGroup::duration(QSequentialAnimationGroup* theWrappedObject) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QSequentialAnimationGroup*)theWrappedObject)->promoted_duration());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QSequentialAnimationGroup::event(QSequentialAnimationGroup* theWrappedObject, QEvent* event)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QSequentialAnimationGroup*)theWrappedObject)->promoted_event(event));
|
|
|
}
|
|
|
|
|
|
QPauseAnimation* PythonQtWrapper_QSequentialAnimationGroup::insertPause(QSequentialAnimationGroup* theWrappedObject, int index, int msecs)
|
|
|
{
|
|
|
return ( theWrappedObject->insertPause(index, msecs));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QSequentialAnimationGroup::updateCurrentTime(QSequentialAnimationGroup* theWrappedObject, int arg__1)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QSequentialAnimationGroup*)theWrappedObject)->promoted_updateCurrentTime(arg__1));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QSequentialAnimationGroup::updateDirection(QSequentialAnimationGroup* theWrappedObject, QAbstractAnimation::Direction direction)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QSequentialAnimationGroup*)theWrappedObject)->promoted_updateDirection(direction));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QSequentialAnimationGroup::updateState(QSequentialAnimationGroup* theWrappedObject, QAbstractAnimation::State newState, QAbstractAnimation::State oldState)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QSequentialAnimationGroup*)theWrappedObject)->promoted_updateState(newState, oldState));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QSettings::~PythonQtShell_QSettings() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QSettings::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;
|
|
|
}
|
|
|
}
|
|
|
QSettings::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QSettings::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;
|
|
|
}
|
|
|
}
|
|
|
QSettings::customEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QSettings::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 QSettings::event(event);
|
|
|
}
|
|
|
bool PythonQtShell_QSettings::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 QSettings::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
void PythonQtShell_QSettings::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;
|
|
|
}
|
|
|
}
|
|
|
QSettings::timerEvent(arg__1);
|
|
|
}
|
|
|
QSettings* PythonQtWrapper_QSettings::new_QSettings(QObject* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QSettings(parent); }
|
|
|
|
|
|
QSettings* PythonQtWrapper_QSettings::new_QSettings(QSettings::Format format, QSettings::Scope scope, const QString& organization, const QString& application, QObject* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QSettings(format, scope, organization, application, parent); }
|
|
|
|
|
|
QSettings* PythonQtWrapper_QSettings::new_QSettings(QSettings::Scope scope, const QString& organization, const QString& application, QObject* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QSettings(scope, organization, application, parent); }
|
|
|
|
|
|
QSettings* PythonQtWrapper_QSettings::new_QSettings(const QString& fileName, QSettings::Format format, QObject* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QSettings(fileName, format, parent); }
|
|
|
|
|
|
QSettings* PythonQtWrapper_QSettings::new_QSettings(const QString& organization, const QString& application, QObject* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QSettings(organization, application, parent); }
|
|
|
|
|
|
QStringList PythonQtWrapper_QSettings::allKeys(QSettings* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->allKeys());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QSettings::applicationName(QSettings* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->applicationName());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QSettings::beginGroup(QSettings* theWrappedObject, const QString& prefix)
|
|
|
{
|
|
|
( theWrappedObject->beginGroup(prefix));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QSettings::beginReadArray(QSettings* theWrappedObject, const QString& prefix)
|
|
|
{
|
|
|
return ( theWrappedObject->beginReadArray(prefix));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QSettings::beginWriteArray(QSettings* theWrappedObject, const QString& prefix, int size)
|
|
|
{
|
|
|
( theWrappedObject->beginWriteArray(prefix, size));
|
|
|
}
|
|
|
|
|
|
QStringList PythonQtWrapper_QSettings::childGroups(QSettings* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->childGroups());
|
|
|
}
|
|
|
|
|
|
QStringList PythonQtWrapper_QSettings::childKeys(QSettings* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->childKeys());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QSettings::clear(QSettings* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->clear());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QSettings::contains(QSettings* theWrappedObject, const QString& key) const
|
|
|
{
|
|
|
return ( theWrappedObject->contains(key));
|
|
|
}
|
|
|
|
|
|
QSettings::Format PythonQtWrapper_QSettings::static_QSettings_defaultFormat()
|
|
|
{
|
|
|
return (QSettings::defaultFormat());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QSettings::endArray(QSettings* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->endArray());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QSettings::endGroup(QSettings* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->endGroup());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QSettings::event(QSettings* theWrappedObject, QEvent* event)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QSettings*)theWrappedObject)->promoted_event(event));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QSettings::fallbacksEnabled(QSettings* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->fallbacksEnabled());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QSettings::fileName(QSettings* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->fileName());
|
|
|
}
|
|
|
|
|
|
QSettings::Format PythonQtWrapper_QSettings::format(QSettings* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->format());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QSettings::group(QSettings* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->group());
|
|
|
}
|
|
|
|
|
|
QTextCodec* PythonQtWrapper_QSettings::iniCodec(QSettings* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->iniCodec());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QSettings::isWritable(QSettings* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isWritable());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QSettings::organizationName(QSettings* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->organizationName());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QSettings::remove(QSettings* theWrappedObject, const QString& key)
|
|
|
{
|
|
|
( theWrappedObject->remove(key));
|
|
|
}
|
|
|
|
|
|
QSettings::Scope PythonQtWrapper_QSettings::scope(QSettings* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->scope());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QSettings::setArrayIndex(QSettings* theWrappedObject, int i)
|
|
|
{
|
|
|
( theWrappedObject->setArrayIndex(i));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QSettings::static_QSettings_setDefaultFormat(QSettings::Format format)
|
|
|
{
|
|
|
(QSettings::setDefaultFormat(format));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QSettings::setFallbacksEnabled(QSettings* theWrappedObject, bool b)
|
|
|
{
|
|
|
( theWrappedObject->setFallbacksEnabled(b));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QSettings::setIniCodec(QSettings* theWrappedObject, QTextCodec* codec)
|
|
|
{
|
|
|
( theWrappedObject->setIniCodec(codec));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QSettings::setIniCodec(QSettings* theWrappedObject, const char* codecName)
|
|
|
{
|
|
|
( theWrappedObject->setIniCodec(codecName));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QSettings::static_QSettings_setPath(QSettings::Format format, QSettings::Scope scope, const QString& path)
|
|
|
{
|
|
|
(QSettings::setPath(format, scope, path));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QSettings::setValue(QSettings* theWrappedObject, const QString& key, const QVariant& value)
|
|
|
{
|
|
|
( theWrappedObject->setValue(key, value));
|
|
|
}
|
|
|
|
|
|
QSettings::Status PythonQtWrapper_QSettings::status(QSettings* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->status());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QSettings::sync(QSettings* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->sync());
|
|
|
}
|
|
|
|
|
|
QVariant PythonQtWrapper_QSettings::value(QSettings* theWrappedObject, const QString& key, const QVariant& defaultValue) const
|
|
|
{
|
|
|
return ( theWrappedObject->value(key, defaultValue));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QSignalMapper::~PythonQtShell_QSignalMapper() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QSignalMapper::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;
|
|
|
}
|
|
|
}
|
|
|
QSignalMapper::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QSignalMapper::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;
|
|
|
}
|
|
|
}
|
|
|
QSignalMapper::customEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QSignalMapper::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 QSignalMapper::event(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QSignalMapper::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 QSignalMapper::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
void PythonQtShell_QSignalMapper::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;
|
|
|
}
|
|
|
}
|
|
|
QSignalMapper::timerEvent(arg__1);
|
|
|
}
|
|
|
QSignalMapper* PythonQtWrapper_QSignalMapper::new_QSignalMapper(QObject* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QSignalMapper(parent); }
|
|
|
|
|
|
QObject* PythonQtWrapper_QSignalMapper::mapping(QSignalMapper* theWrappedObject, QObject* object) const
|
|
|
{
|
|
|
return ( theWrappedObject->mapping(object));
|
|
|
}
|
|
|
|
|
|
QObject* PythonQtWrapper_QSignalMapper::mapping(QSignalMapper* theWrappedObject, const QString& text) const
|
|
|
{
|
|
|
return ( theWrappedObject->mapping(text));
|
|
|
}
|
|
|
|
|
|
QObject* PythonQtWrapper_QSignalMapper::mapping(QSignalMapper* theWrappedObject, int id) const
|
|
|
{
|
|
|
return ( theWrappedObject->mapping(id));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QSignalMapper::removeMappings(QSignalMapper* theWrappedObject, QObject* sender)
|
|
|
{
|
|
|
( theWrappedObject->removeMappings(sender));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QSignalMapper::setMapping(QSignalMapper* theWrappedObject, QObject* sender, QObject* object)
|
|
|
{
|
|
|
( theWrappedObject->setMapping(sender, object));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QSignalMapper::setMapping(QSignalMapper* theWrappedObject, QObject* sender, const QString& text)
|
|
|
{
|
|
|
( theWrappedObject->setMapping(sender, text));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QSignalMapper::setMapping(QSignalMapper* theWrappedObject, QObject* sender, int id)
|
|
|
{
|
|
|
( theWrappedObject->setMapping(sender, id));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QSignalTransition::~PythonQtShell_QSignalTransition() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QSignalTransition::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;
|
|
|
}
|
|
|
}
|
|
|
QSignalTransition::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QSignalTransition::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;
|
|
|
}
|
|
|
}
|
|
|
QSignalTransition::customEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QSignalTransition::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 QSignalTransition::event(e);
|
|
|
}
|
|
|
bool PythonQtShell_QSignalTransition::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 QSignalTransition::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
bool PythonQtShell_QSignalTransition::eventTest(QEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventTest");
|
|
|
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("eventTest", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QSignalTransition::eventTest(event);
|
|
|
}
|
|
|
void PythonQtShell_QSignalTransition::onTransition(QEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "onTransition");
|
|
|
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*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QSignalTransition::onTransition(event);
|
|
|
}
|
|
|
void PythonQtShell_QSignalTransition::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;
|
|
|
}
|
|
|
}
|
|
|
QSignalTransition::timerEvent(arg__1);
|
|
|
}
|
|
|
QSignalTransition* PythonQtWrapper_QSignalTransition::new_QSignalTransition(QState* sourceState)
|
|
|
{
|
|
|
return new PythonQtShell_QSignalTransition(sourceState); }
|
|
|
|
|
|
QSignalTransition* PythonQtWrapper_QSignalTransition::new_QSignalTransition(const QObject* sender, const char* signal, QState* sourceState)
|
|
|
{
|
|
|
return new PythonQtShell_QSignalTransition(sender, signal, sourceState); }
|
|
|
|
|
|
bool PythonQtWrapper_QSignalTransition::event(QSignalTransition* theWrappedObject, QEvent* e)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QSignalTransition*)theWrappedObject)->promoted_event(e));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QSignalTransition::eventTest(QSignalTransition* theWrappedObject, QEvent* event)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QSignalTransition*)theWrappedObject)->promoted_eventTest(event));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QSignalTransition::onTransition(QSignalTransition* theWrappedObject, QEvent* event)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QSignalTransition*)theWrappedObject)->promoted_onTransition(event));
|
|
|
}
|
|
|
|
|
|
QObject* PythonQtWrapper_QSignalTransition::senderObject(QSignalTransition* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->senderObject());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QSignalTransition::setSenderObject(QSignalTransition* theWrappedObject, const QObject* sender)
|
|
|
{
|
|
|
( theWrappedObject->setSenderObject(sender));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QSignalTransition::setSignal(QSignalTransition* theWrappedObject, const QByteArray& signal)
|
|
|
{
|
|
|
( theWrappedObject->setSignal(signal));
|
|
|
}
|
|
|
|
|
|
QByteArray PythonQtWrapper_QSignalTransition::signal(QSignalTransition* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->signal());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool PythonQtWrapper_QSocketNotifier::event(QSocketNotifier* theWrappedObject, QEvent* arg__1)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QSocketNotifier*)theWrappedObject)->promoted_event(arg__1));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QSocketNotifier::isEnabled(QSocketNotifier* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isEnabled());
|
|
|
}
|
|
|
|
|
|
QSocketNotifier::Type PythonQtWrapper_QSocketNotifier::type(QSocketNotifier* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->type());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QState::~PythonQtShell_QState() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QState::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;
|
|
|
}
|
|
|
}
|
|
|
QState::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QState::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;
|
|
|
}
|
|
|
}
|
|
|
QState::customEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QState::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 QState::event(e);
|
|
|
}
|
|
|
bool PythonQtShell_QState::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 QState::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
void PythonQtShell_QState::onEntry(QEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "onEntry");
|
|
|
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*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QState::onEntry(event);
|
|
|
}
|
|
|
void PythonQtShell_QState::onExit(QEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "onExit");
|
|
|
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*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QState::onExit(event);
|
|
|
}
|
|
|
void PythonQtShell_QState::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;
|
|
|
}
|
|
|
}
|
|
|
QState::timerEvent(arg__1);
|
|
|
}
|
|
|
QState* PythonQtWrapper_QState::new_QState(QState* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QState(parent); }
|
|
|
|
|
|
QState* PythonQtWrapper_QState::new_QState(QState::ChildMode childMode, QState* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QState(childMode, parent); }
|
|
|
|
|
|
QAbstractTransition* PythonQtWrapper_QState::addTransition(QState* theWrappedObject, QAbstractState* target)
|
|
|
{
|
|
|
return ( theWrappedObject->addTransition(target));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QState::addTransition(QState* theWrappedObject, QAbstractTransition* transition)
|
|
|
{
|
|
|
( theWrappedObject->addTransition(transition));
|
|
|
}
|
|
|
|
|
|
QSignalTransition* PythonQtWrapper_QState::addTransition(QState* theWrappedObject, const QObject* sender, const char* signal, QAbstractState* target)
|
|
|
{
|
|
|
return ( theWrappedObject->addTransition(sender, signal, target));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QState::assignProperty(QState* theWrappedObject, QObject* object, const char* name, const QVariant& value)
|
|
|
{
|
|
|
( theWrappedObject->assignProperty(object, name, value));
|
|
|
}
|
|
|
|
|
|
QState::ChildMode PythonQtWrapper_QState::childMode(QState* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->childMode());
|
|
|
}
|
|
|
|
|
|
QAbstractState* PythonQtWrapper_QState::errorState(QState* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->errorState());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QState::event(QState* theWrappedObject, QEvent* e)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QState*)theWrappedObject)->promoted_event(e));
|
|
|
}
|
|
|
|
|
|
QAbstractState* PythonQtWrapper_QState::initialState(QState* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->initialState());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QState::onEntry(QState* theWrappedObject, QEvent* event)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QState*)theWrappedObject)->promoted_onEntry(event));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QState::onExit(QState* theWrappedObject, QEvent* event)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QState*)theWrappedObject)->promoted_onExit(event));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QState::removeTransition(QState* theWrappedObject, QAbstractTransition* transition)
|
|
|
{
|
|
|
( theWrappedObject->removeTransition(transition));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QState::setChildMode(QState* theWrappedObject, QState::ChildMode mode)
|
|
|
{
|
|
|
( theWrappedObject->setChildMode(mode));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QState::setErrorState(QState* theWrappedObject, QAbstractState* state)
|
|
|
{
|
|
|
( theWrappedObject->setErrorState(state));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QState::setInitialState(QState* theWrappedObject, QAbstractState* state)
|
|
|
{
|
|
|
( theWrappedObject->setInitialState(state));
|
|
|
}
|
|
|
|
|
|
QList<QAbstractTransition* > PythonQtWrapper_QState::transitions(QState* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->transitions());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QStateMachine::~PythonQtShell_QStateMachine() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QStateMachine::beginMicrostep(QEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "beginMicrostep");
|
|
|
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*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QStateMachine::beginMicrostep(event);
|
|
|
}
|
|
|
void PythonQtShell_QStateMachine::beginSelectTransitions(QEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "beginSelectTransitions");
|
|
|
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*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QStateMachine::beginSelectTransitions(event);
|
|
|
}
|
|
|
void PythonQtShell_QStateMachine::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;
|
|
|
}
|
|
|
}
|
|
|
QStateMachine::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QStateMachine::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;
|
|
|
}
|
|
|
}
|
|
|
QStateMachine::customEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QStateMachine::endMicrostep(QEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "endMicrostep");
|
|
|
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*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QStateMachine::endMicrostep(event);
|
|
|
}
|
|
|
void PythonQtShell_QStateMachine::endSelectTransitions(QEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "endSelectTransitions");
|
|
|
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*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QStateMachine::endSelectTransitions(event);
|
|
|
}
|
|
|
bool PythonQtShell_QStateMachine::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 QStateMachine::event(e);
|
|
|
}
|
|
|
bool PythonQtShell_QStateMachine::eventFilter(QObject* watched, QEvent* event)
|
|
|
{
|
|
|
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*)&watched, (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("eventFilter", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((bool*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QStateMachine::eventFilter(watched, event);
|
|
|
}
|
|
|
void PythonQtShell_QStateMachine::onEntry(QEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "onEntry");
|
|
|
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*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QStateMachine::onEntry(event);
|
|
|
}
|
|
|
void PythonQtShell_QStateMachine::onExit(QEvent* event)
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "onExit");
|
|
|
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*)&event};
|
|
|
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
QStateMachine::onExit(event);
|
|
|
}
|
|
|
void PythonQtShell_QStateMachine::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;
|
|
|
}
|
|
|
}
|
|
|
QStateMachine::timerEvent(arg__1);
|
|
|
}
|
|
|
QStateMachine* PythonQtWrapper_QStateMachine::new_QStateMachine(QObject* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QStateMachine(parent); }
|
|
|
|
|
|
QStateMachine* PythonQtWrapper_QStateMachine::new_QStateMachine(QState::ChildMode childMode, QObject* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QStateMachine(childMode, parent); }
|
|
|
|
|
|
void PythonQtWrapper_QStateMachine::addDefaultAnimation(QStateMachine* theWrappedObject, QAbstractAnimation* animation)
|
|
|
{
|
|
|
( theWrappedObject->addDefaultAnimation(animation));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QStateMachine::addState(QStateMachine* theWrappedObject, QAbstractState* state)
|
|
|
{
|
|
|
( theWrappedObject->addState(state));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QStateMachine::beginMicrostep(QStateMachine* theWrappedObject, QEvent* event)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QStateMachine*)theWrappedObject)->promoted_beginMicrostep(event));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QStateMachine::beginSelectTransitions(QStateMachine* theWrappedObject, QEvent* event)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QStateMachine*)theWrappedObject)->promoted_beginSelectTransitions(event));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QStateMachine::cancelDelayedEvent(QStateMachine* theWrappedObject, int id)
|
|
|
{
|
|
|
return ( theWrappedObject->cancelDelayedEvent(id));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QStateMachine::clearError(QStateMachine* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->clearError());
|
|
|
}
|
|
|
|
|
|
QSet<QAbstractState* > PythonQtWrapper_QStateMachine::configuration(QStateMachine* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->configuration());
|
|
|
}
|
|
|
|
|
|
QList<QAbstractAnimation* > PythonQtWrapper_QStateMachine::defaultAnimations(QStateMachine* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->defaultAnimations());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QStateMachine::endMicrostep(QStateMachine* theWrappedObject, QEvent* event)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QStateMachine*)theWrappedObject)->promoted_endMicrostep(event));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QStateMachine::endSelectTransitions(QStateMachine* theWrappedObject, QEvent* event)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QStateMachine*)theWrappedObject)->promoted_endSelectTransitions(event));
|
|
|
}
|
|
|
|
|
|
QStateMachine::Error PythonQtWrapper_QStateMachine::error(QStateMachine* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->error());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QStateMachine::errorString(QStateMachine* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->errorString());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QStateMachine::event(QStateMachine* theWrappedObject, QEvent* e)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QStateMachine*)theWrappedObject)->promoted_event(e));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QStateMachine::eventFilter(QStateMachine* theWrappedObject, QObject* watched, QEvent* event)
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QStateMachine*)theWrappedObject)->promoted_eventFilter(watched, event));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QStateMachine::isAnimated(QStateMachine* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isAnimated());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QStateMachine::isRunning(QStateMachine* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isRunning());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QStateMachine::onEntry(QStateMachine* theWrappedObject, QEvent* event)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QStateMachine*)theWrappedObject)->promoted_onEntry(event));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QStateMachine::onExit(QStateMachine* theWrappedObject, QEvent* event)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QStateMachine*)theWrappedObject)->promoted_onExit(event));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QStateMachine::postDelayedEvent(QStateMachine* theWrappedObject, QEvent* event, int delay)
|
|
|
{
|
|
|
return ( theWrappedObject->postDelayedEvent(event, delay));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QStateMachine::postEvent(QStateMachine* theWrappedObject, QEvent* event, QStateMachine::EventPriority priority)
|
|
|
{
|
|
|
( theWrappedObject->postEvent(event, priority));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QStateMachine::removeDefaultAnimation(QStateMachine* theWrappedObject, QAbstractAnimation* animation)
|
|
|
{
|
|
|
( theWrappedObject->removeDefaultAnimation(animation));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QStateMachine::removeState(QStateMachine* theWrappedObject, QAbstractState* state)
|
|
|
{
|
|
|
( theWrappedObject->removeState(state));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QStateMachine::setAnimated(QStateMachine* theWrappedObject, bool enabled)
|
|
|
{
|
|
|
( theWrappedObject->setAnimated(enabled));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QStateMachine::SignalEvent* PythonQtWrapper_QStateMachine_SignalEvent::new_QStateMachine_SignalEvent(QObject* sender, int signalIndex, const QList<QVariant >& arguments)
|
|
|
{
|
|
|
return new QStateMachine::SignalEvent(sender, signalIndex, arguments); }
|
|
|
|
|
|
QList<QVariant > PythonQtWrapper_QStateMachine_SignalEvent::arguments(QStateMachine::SignalEvent* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->arguments());
|
|
|
}
|
|
|
|
|
|
QObject* PythonQtWrapper_QStateMachine_SignalEvent::sender(QStateMachine::SignalEvent* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->sender());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QStateMachine_SignalEvent::signalIndex(QStateMachine::SignalEvent* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->signalIndex());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QStateMachine::WrappedEvent* PythonQtWrapper_QStateMachine_WrappedEvent::new_QStateMachine_WrappedEvent(QObject* object, QEvent* event)
|
|
|
{
|
|
|
return new QStateMachine::WrappedEvent(object, event); }
|
|
|
|
|
|
QEvent* PythonQtWrapper_QStateMachine_WrappedEvent::event(QStateMachine::WrappedEvent* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->event());
|
|
|
}
|
|
|
|
|
|
QObject* PythonQtWrapper_QStateMachine_WrappedEvent::object(QStateMachine::WrappedEvent* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->object());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QStringMatcher* PythonQtWrapper_QStringMatcher::new_QStringMatcher()
|
|
|
{
|
|
|
return new QStringMatcher(); }
|
|
|
|
|
|
QStringMatcher* PythonQtWrapper_QStringMatcher::new_QStringMatcher(const QString& pattern, Qt::CaseSensitivity cs)
|
|
|
{
|
|
|
return new QStringMatcher(pattern, cs); }
|
|
|
|
|
|
QStringMatcher* PythonQtWrapper_QStringMatcher::new_QStringMatcher(const QStringMatcher& other)
|
|
|
{
|
|
|
return new QStringMatcher(other); }
|
|
|
|
|
|
Qt::CaseSensitivity PythonQtWrapper_QStringMatcher::caseSensitivity(QStringMatcher* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->caseSensitivity());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QStringMatcher::indexIn(QStringMatcher* theWrappedObject, const QString& str, int from) const
|
|
|
{
|
|
|
return ( theWrappedObject->indexIn(str, from));
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QStringMatcher::pattern(QStringMatcher* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->pattern());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QStringMatcher::setCaseSensitivity(QStringMatcher* theWrappedObject, Qt::CaseSensitivity cs)
|
|
|
{
|
|
|
( theWrappedObject->setCaseSensitivity(cs));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QStringMatcher::setPattern(QStringMatcher* theWrappedObject, const QString& pattern)
|
|
|
{
|
|
|
( theWrappedObject->setPattern(pattern));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QSystemSemaphore* PythonQtWrapper_QSystemSemaphore::new_QSystemSemaphore(const QString& key, int initialValue, QSystemSemaphore::AccessMode mode)
|
|
|
{
|
|
|
return new QSystemSemaphore(key, initialValue, mode); }
|
|
|
|
|
|
bool PythonQtWrapper_QSystemSemaphore::acquire(QSystemSemaphore* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->acquire());
|
|
|
}
|
|
|
|
|
|
QSystemSemaphore::SystemSemaphoreError PythonQtWrapper_QSystemSemaphore::error(QSystemSemaphore* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->error());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QSystemSemaphore::errorString(QSystemSemaphore* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->errorString());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QSystemSemaphore::key(QSystemSemaphore* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->key());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QSystemSemaphore::release(QSystemSemaphore* theWrappedObject, int n)
|
|
|
{
|
|
|
return ( theWrappedObject->release(n));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QSystemSemaphore::setKey(QSystemSemaphore* theWrappedObject, const QString& key, int initialValue, QSystemSemaphore::AccessMode mode)
|
|
|
{
|
|
|
( theWrappedObject->setKey(key, initialValue, mode));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QTemporaryFile* PythonQtWrapper_QTemporaryFile::new_QTemporaryFile()
|
|
|
{
|
|
|
return new QTemporaryFile(); }
|
|
|
|
|
|
QTemporaryFile* PythonQtWrapper_QTemporaryFile::new_QTemporaryFile(QObject* parent)
|
|
|
{
|
|
|
return new QTemporaryFile(parent); }
|
|
|
|
|
|
QTemporaryFile* PythonQtWrapper_QTemporaryFile::new_QTemporaryFile(const QString& templateName)
|
|
|
{
|
|
|
return new QTemporaryFile(templateName); }
|
|
|
|
|
|
QTemporaryFile* PythonQtWrapper_QTemporaryFile::new_QTemporaryFile(const QString& templateName, QObject* parent)
|
|
|
{
|
|
|
return new QTemporaryFile(templateName, parent); }
|
|
|
|
|
|
bool PythonQtWrapper_QTemporaryFile::autoRemove(QTemporaryFile* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->autoRemove());
|
|
|
}
|
|
|
|
|
|
QTemporaryFile* PythonQtWrapper_QTemporaryFile::static_QTemporaryFile_createLocalFile(QFile& file)
|
|
|
{
|
|
|
return (QTemporaryFile::createLocalFile(file));
|
|
|
}
|
|
|
|
|
|
QTemporaryFile* PythonQtWrapper_QTemporaryFile::static_QTemporaryFile_createLocalFile(const QString& fileName)
|
|
|
{
|
|
|
return (QTemporaryFile::createLocalFile(fileName));
|
|
|
}
|
|
|
|
|
|
QTemporaryFile* PythonQtWrapper_QTemporaryFile::static_QTemporaryFile_createNativeFile(QFile& file)
|
|
|
{
|
|
|
return (QTemporaryFile::createNativeFile(file));
|
|
|
}
|
|
|
|
|
|
QTemporaryFile* PythonQtWrapper_QTemporaryFile::static_QTemporaryFile_createNativeFile(const QString& fileName)
|
|
|
{
|
|
|
return (QTemporaryFile::createNativeFile(fileName));
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QTemporaryFile::fileName(QTemporaryFile* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->fileName());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QTemporaryFile::fileTemplate(QTemporaryFile* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->fileTemplate());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTemporaryFile::open(QTemporaryFile* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->open());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTemporaryFile::setAutoRemove(QTemporaryFile* theWrappedObject, bool b)
|
|
|
{
|
|
|
( theWrappedObject->setAutoRemove(b));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTemporaryFile::setFileTemplate(QTemporaryFile* theWrappedObject, const QString& name)
|
|
|
{
|
|
|
( theWrappedObject->setFileTemplate(name));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QTextBoundaryFinder* PythonQtWrapper_QTextBoundaryFinder::new_QTextBoundaryFinder()
|
|
|
{
|
|
|
return new QTextBoundaryFinder(); }
|
|
|
|
|
|
QTextBoundaryFinder* PythonQtWrapper_QTextBoundaryFinder::new_QTextBoundaryFinder(QTextBoundaryFinder::BoundaryType type, const QString& string)
|
|
|
{
|
|
|
return new QTextBoundaryFinder(type, string); }
|
|
|
|
|
|
QTextBoundaryFinder* PythonQtWrapper_QTextBoundaryFinder::new_QTextBoundaryFinder(const QTextBoundaryFinder& other)
|
|
|
{
|
|
|
return new QTextBoundaryFinder(other); }
|
|
|
|
|
|
QTextBoundaryFinder::BoundaryReasons PythonQtWrapper_QTextBoundaryFinder::boundaryReasons(QTextBoundaryFinder* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->boundaryReasons());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextBoundaryFinder::isAtBoundary(QTextBoundaryFinder* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isAtBoundary());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextBoundaryFinder::isValid(QTextBoundaryFinder* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->isValid());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextBoundaryFinder::position(QTextBoundaryFinder* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->position());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextBoundaryFinder::setPosition(QTextBoundaryFinder* theWrappedObject, int position)
|
|
|
{
|
|
|
( theWrappedObject->setPosition(position));
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QTextBoundaryFinder::string(QTextBoundaryFinder* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->string());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextBoundaryFinder::toEnd(QTextBoundaryFinder* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->toEnd());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextBoundaryFinder::toNextBoundary(QTextBoundaryFinder* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->toNextBoundary());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextBoundaryFinder::toPreviousBoundary(QTextBoundaryFinder* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->toPreviousBoundary());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextBoundaryFinder::toStart(QTextBoundaryFinder* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->toStart());
|
|
|
}
|
|
|
|
|
|
QTextBoundaryFinder::BoundaryType PythonQtWrapper_QTextBoundaryFinder::type(QTextBoundaryFinder* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->type());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QTextCodec::~PythonQtShell_QTextCodec() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
QList<QByteArray > PythonQtShell_QTextCodec::aliases() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "aliases");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QList<QByteArray >"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QList<QByteArray > 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("aliases", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QList<QByteArray >*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTextCodec::aliases();
|
|
|
}
|
|
|
QByteArray PythonQtShell_QTextCodec::convertFromUnicode(const QChar* in, int length, QTextCodec::ConverterState* state) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "convertFromUnicode");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QByteArray" , "const QChar*" , "int" , "QTextCodec::ConverterState*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
|
|
|
QByteArray returnValue;
|
|
|
void* args[4] = {NULL, (void*)&in, (void*)&length, (void*)&state};
|
|
|
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("convertFromUnicode", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QByteArray*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QByteArray();
|
|
|
}
|
|
|
QString PythonQtShell_QTextCodec::convertToUnicode(const char* in, int length, QTextCodec::ConverterState* state) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "convertToUnicode");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QString" , "const char*" , "int" , "QTextCodec::ConverterState*"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
|
|
|
QString returnValue;
|
|
|
void* args[4] = {NULL, (void*)&in, (void*)&length, (void*)&state};
|
|
|
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("convertToUnicode", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QString*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QString();
|
|
|
}
|
|
|
int PythonQtShell_QTextCodec::mibEnum() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mibEnum");
|
|
|
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("mibEnum", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((int*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return int();
|
|
|
}
|
|
|
QByteArray PythonQtShell_QTextCodec::name() const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "name");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"QByteArray"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
|
|
QByteArray 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("name", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((QByteArray*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QByteArray();
|
|
|
}
|
|
|
QList<QByteArray > PythonQtWrapper_QTextCodec::aliases(QTextCodec* theWrappedObject) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QTextCodec*)theWrappedObject)->promoted_aliases());
|
|
|
}
|
|
|
|
|
|
QList<QByteArray > PythonQtWrapper_QTextCodec::static_QTextCodec_availableCodecs()
|
|
|
{
|
|
|
return (QTextCodec::availableCodecs());
|
|
|
}
|
|
|
|
|
|
QList<int > PythonQtWrapper_QTextCodec::static_QTextCodec_availableMibs()
|
|
|
{
|
|
|
return (QTextCodec::availableMibs());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextCodec::canEncode(QTextCodec* theWrappedObject, QChar arg__1) const
|
|
|
{
|
|
|
return ( theWrappedObject->canEncode(arg__1));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextCodec::canEncode(QTextCodec* theWrappedObject, const QString& arg__1) const
|
|
|
{
|
|
|
return ( theWrappedObject->canEncode(arg__1));
|
|
|
}
|
|
|
|
|
|
QTextCodec* PythonQtWrapper_QTextCodec::static_QTextCodec_codecForHtml(const QByteArray& ba)
|
|
|
{
|
|
|
return (QTextCodec::codecForHtml(ba));
|
|
|
}
|
|
|
|
|
|
QTextCodec* PythonQtWrapper_QTextCodec::static_QTextCodec_codecForHtml(const QByteArray& ba, QTextCodec* defaultCodec)
|
|
|
{
|
|
|
return (QTextCodec::codecForHtml(ba, defaultCodec));
|
|
|
}
|
|
|
|
|
|
QTextCodec* PythonQtWrapper_QTextCodec::static_QTextCodec_codecForLocale()
|
|
|
{
|
|
|
return (QTextCodec::codecForLocale());
|
|
|
}
|
|
|
|
|
|
QTextCodec* PythonQtWrapper_QTextCodec::static_QTextCodec_codecForMib(int mib)
|
|
|
{
|
|
|
return (QTextCodec::codecForMib(mib));
|
|
|
}
|
|
|
|
|
|
QTextCodec* PythonQtWrapper_QTextCodec::static_QTextCodec_codecForName(const QByteArray& name)
|
|
|
{
|
|
|
return (QTextCodec::codecForName(name));
|
|
|
}
|
|
|
|
|
|
QTextCodec* PythonQtWrapper_QTextCodec::static_QTextCodec_codecForName(const char* name)
|
|
|
{
|
|
|
return (QTextCodec::codecForName(name));
|
|
|
}
|
|
|
|
|
|
QTextCodec* PythonQtWrapper_QTextCodec::static_QTextCodec_codecForUtfText(const QByteArray& ba)
|
|
|
{
|
|
|
return (QTextCodec::codecForUtfText(ba));
|
|
|
}
|
|
|
|
|
|
QTextCodec* PythonQtWrapper_QTextCodec::static_QTextCodec_codecForUtfText(const QByteArray& ba, QTextCodec* defaultCodec)
|
|
|
{
|
|
|
return (QTextCodec::codecForUtfText(ba, defaultCodec));
|
|
|
}
|
|
|
|
|
|
QByteArray PythonQtWrapper_QTextCodec::fromUnicode(QTextCodec* theWrappedObject, const QString& uc) const
|
|
|
{
|
|
|
return ( theWrappedObject->fromUnicode(uc));
|
|
|
}
|
|
|
|
|
|
QTextDecoder* PythonQtWrapper_QTextCodec::makeDecoder(QTextCodec* theWrappedObject, QTextCodec::ConversionFlags flags) const
|
|
|
{
|
|
|
return ( theWrappedObject->makeDecoder(flags));
|
|
|
}
|
|
|
|
|
|
QTextEncoder* PythonQtWrapper_QTextCodec::makeEncoder(QTextCodec* theWrappedObject, QTextCodec::ConversionFlags flags) const
|
|
|
{
|
|
|
return ( theWrappedObject->makeEncoder(flags));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextCodec::static_QTextCodec_setCodecForLocale(QTextCodec* c)
|
|
|
{
|
|
|
(QTextCodec::setCodecForLocale(c));
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QTextCodec::toUnicode(QTextCodec* theWrappedObject, const QByteArray& arg__1) const
|
|
|
{
|
|
|
return ( theWrappedObject->toUnicode(arg__1));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QTextDecoder* PythonQtWrapper_QTextDecoder::new_QTextDecoder(const QTextCodec* codec)
|
|
|
{
|
|
|
return new QTextDecoder(codec); }
|
|
|
|
|
|
QTextDecoder* PythonQtWrapper_QTextDecoder::new_QTextDecoder(const QTextCodec* codec, QTextCodec::ConversionFlags flags)
|
|
|
{
|
|
|
return new QTextDecoder(codec, flags); }
|
|
|
|
|
|
bool PythonQtWrapper_QTextDecoder::hasFailure(QTextDecoder* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->hasFailure());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QTextDecoder::toUnicode(QTextDecoder* theWrappedObject, const QByteArray& ba)
|
|
|
{
|
|
|
return ( theWrappedObject->toUnicode(ba));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
QTextEncoder* PythonQtWrapper_QTextEncoder::new_QTextEncoder(const QTextCodec* codec)
|
|
|
{
|
|
|
return new QTextEncoder(codec); }
|
|
|
|
|
|
QTextEncoder* PythonQtWrapper_QTextEncoder::new_QTextEncoder(const QTextCodec* codec, QTextCodec::ConversionFlags flags)
|
|
|
{
|
|
|
return new QTextEncoder(codec, flags); }
|
|
|
|
|
|
QByteArray PythonQtWrapper_QTextEncoder::fromUnicode(QTextEncoder* theWrappedObject, const QString& str)
|
|
|
{
|
|
|
return ( theWrappedObject->fromUnicode(str));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextEncoder::hasFailure(QTextEncoder* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->hasFailure());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QTextStream::~PythonQtShell_QTextStream() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
QTextStream* PythonQtWrapper_QTextStream::new_QTextStream()
|
|
|
{
|
|
|
return new PythonQtShell_QTextStream(); }
|
|
|
|
|
|
QTextStream* PythonQtWrapper_QTextStream::new_QTextStream(QIODevice* device)
|
|
|
{
|
|
|
return new PythonQtShell_QTextStream(device); }
|
|
|
|
|
|
QTextStream* PythonQtWrapper_QTextStream::new_QTextStream(const QByteArray& array, QIODevice::OpenMode openMode)
|
|
|
{
|
|
|
return new PythonQtShell_QTextStream(array, openMode); }
|
|
|
|
|
|
bool PythonQtWrapper_QTextStream::atEnd(QTextStream* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->atEnd());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextStream::autoDetectUnicode(QTextStream* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->autoDetectUnicode());
|
|
|
}
|
|
|
|
|
|
QTextCodec* PythonQtWrapper_QTextStream::codec(QTextStream* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->codec());
|
|
|
}
|
|
|
|
|
|
QIODevice* PythonQtWrapper_QTextStream::device(QTextStream* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->device());
|
|
|
}
|
|
|
|
|
|
QTextStream::FieldAlignment PythonQtWrapper_QTextStream::fieldAlignment(QTextStream* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->fieldAlignment());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextStream::fieldWidth(QTextStream* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->fieldWidth());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextStream::flush(QTextStream* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->flush());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextStream::generateByteOrderMark(QTextStream* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->generateByteOrderMark());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextStream::integerBase(QTextStream* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->integerBase());
|
|
|
}
|
|
|
|
|
|
QLocale PythonQtWrapper_QTextStream::locale(QTextStream* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->locale());
|
|
|
}
|
|
|
|
|
|
QTextStream::NumberFlags PythonQtWrapper_QTextStream::numberFlags(QTextStream* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->numberFlags());
|
|
|
}
|
|
|
|
|
|
QTextStream* PythonQtWrapper_QTextStream::writeByte(QTextStream* theWrappedObject, char ch)
|
|
|
{
|
|
|
return &( (*theWrappedObject) <<ch);
|
|
|
}
|
|
|
|
|
|
QTextStream* PythonQtWrapper_QTextStream::writeByteArray(QTextStream* theWrappedObject, const QByteArray& array)
|
|
|
{
|
|
|
return &( (*theWrappedObject) <<array);
|
|
|
}
|
|
|
|
|
|
QTextStream* PythonQtWrapper_QTextStream::writeString(QTextStream* theWrappedObject, const QString& s)
|
|
|
{
|
|
|
return &( (*theWrappedObject) <<s);
|
|
|
}
|
|
|
|
|
|
QTextStream* PythonQtWrapper_QTextStream::writeDouble(QTextStream* theWrappedObject, double f)
|
|
|
{
|
|
|
return &( (*theWrappedObject) <<f);
|
|
|
}
|
|
|
|
|
|
QTextStream* PythonQtWrapper_QTextStream::writeFloat(QTextStream* theWrappedObject, float f)
|
|
|
{
|
|
|
return &( (*theWrappedObject) <<f);
|
|
|
}
|
|
|
|
|
|
QTextStream* PythonQtWrapper_QTextStream::writeInt(QTextStream* theWrappedObject, signed int i)
|
|
|
{
|
|
|
return &( (*theWrappedObject) <<i);
|
|
|
}
|
|
|
|
|
|
QTextStream* PythonQtWrapper_QTextStream::writeShort(QTextStream* theWrappedObject, signed short i)
|
|
|
{
|
|
|
return &( (*theWrappedObject) <<i);
|
|
|
}
|
|
|
|
|
|
QTextStream* PythonQtWrapper_QTextStream::readByte(QTextStream* theWrappedObject, char& ch)
|
|
|
{
|
|
|
return &( (*theWrappedObject) >>ch);
|
|
|
}
|
|
|
|
|
|
QTextStream* PythonQtWrapper_QTextStream::readDouble(QTextStream* theWrappedObject, double& f)
|
|
|
{
|
|
|
return &( (*theWrappedObject) >>f);
|
|
|
}
|
|
|
|
|
|
QTextStream* PythonQtWrapper_QTextStream::readFloat(QTextStream* theWrappedObject, float& f)
|
|
|
{
|
|
|
return &( (*theWrappedObject) >>f);
|
|
|
}
|
|
|
|
|
|
QTextStream* PythonQtWrapper_QTextStream::readLongLong(QTextStream* theWrappedObject, qlonglong& i)
|
|
|
{
|
|
|
return &( (*theWrappedObject) >>i);
|
|
|
}
|
|
|
|
|
|
QTextStream* PythonQtWrapper_QTextStream::readInt(QTextStream* theWrappedObject, signed int& i)
|
|
|
{
|
|
|
return &( (*theWrappedObject) >>i);
|
|
|
}
|
|
|
|
|
|
QTextStream* PythonQtWrapper_QTextStream::readShort(QTextStream* theWrappedObject, signed short& i)
|
|
|
{
|
|
|
return &( (*theWrappedObject) >>i);
|
|
|
}
|
|
|
|
|
|
QTextStream* PythonQtWrapper_QTextStream::readUInt(QTextStream* theWrappedObject, unsigned int& i)
|
|
|
{
|
|
|
return &( (*theWrappedObject) >>i);
|
|
|
}
|
|
|
|
|
|
QTextStream* PythonQtWrapper_QTextStream::readUShort(QTextStream* theWrappedObject, unsigned short& i)
|
|
|
{
|
|
|
return &( (*theWrappedObject) >>i);
|
|
|
}
|
|
|
|
|
|
QChar PythonQtWrapper_QTextStream::padChar(QTextStream* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->padChar());
|
|
|
}
|
|
|
|
|
|
qint64 PythonQtWrapper_QTextStream::pos(QTextStream* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->pos());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QTextStream::read(QTextStream* theWrappedObject, qint64 maxlen)
|
|
|
{
|
|
|
return ( theWrappedObject->read(maxlen));
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QTextStream::readAll(QTextStream* theWrappedObject)
|
|
|
{
|
|
|
return ( theWrappedObject->readAll());
|
|
|
}
|
|
|
|
|
|
QString PythonQtWrapper_QTextStream::readLine(QTextStream* theWrappedObject, qint64 maxlen)
|
|
|
{
|
|
|
return ( theWrappedObject->readLine(maxlen));
|
|
|
}
|
|
|
|
|
|
QTextStream::RealNumberNotation PythonQtWrapper_QTextStream::realNumberNotation(QTextStream* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->realNumberNotation());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTextStream::realNumberPrecision(QTextStream* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->realNumberPrecision());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextStream::reset(QTextStream* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->reset());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextStream::resetStatus(QTextStream* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->resetStatus());
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QTextStream::seek(QTextStream* theWrappedObject, qint64 pos)
|
|
|
{
|
|
|
return ( theWrappedObject->seek(pos));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextStream::setAutoDetectUnicode(QTextStream* theWrappedObject, bool enabled)
|
|
|
{
|
|
|
( theWrappedObject->setAutoDetectUnicode(enabled));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextStream::setCodec(QTextStream* theWrappedObject, QTextCodec* codec)
|
|
|
{
|
|
|
( theWrappedObject->setCodec(codec));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextStream::setCodec(QTextStream* theWrappedObject, const char* codecName)
|
|
|
{
|
|
|
( theWrappedObject->setCodec(codecName));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextStream::setDevice(QTextStream* theWrappedObject, QIODevice* device)
|
|
|
{
|
|
|
( theWrappedObject->setDevice(device));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextStream::setFieldAlignment(QTextStream* theWrappedObject, QTextStream::FieldAlignment alignment)
|
|
|
{
|
|
|
( theWrappedObject->setFieldAlignment(alignment));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextStream::setFieldWidth(QTextStream* theWrappedObject, int width)
|
|
|
{
|
|
|
( theWrappedObject->setFieldWidth(width));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextStream::setGenerateByteOrderMark(QTextStream* theWrappedObject, bool generate)
|
|
|
{
|
|
|
( theWrappedObject->setGenerateByteOrderMark(generate));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextStream::setIntegerBase(QTextStream* theWrappedObject, int base)
|
|
|
{
|
|
|
( theWrappedObject->setIntegerBase(base));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextStream::setLocale(QTextStream* theWrappedObject, const QLocale& locale)
|
|
|
{
|
|
|
( theWrappedObject->setLocale(locale));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextStream::setNumberFlags(QTextStream* theWrappedObject, QTextStream::NumberFlags flags)
|
|
|
{
|
|
|
( theWrappedObject->setNumberFlags(flags));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextStream::setPadChar(QTextStream* theWrappedObject, QChar ch)
|
|
|
{
|
|
|
( theWrappedObject->setPadChar(ch));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextStream::setRealNumberNotation(QTextStream* theWrappedObject, QTextStream::RealNumberNotation notation)
|
|
|
{
|
|
|
( theWrappedObject->setRealNumberNotation(notation));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextStream::setRealNumberPrecision(QTextStream* theWrappedObject, int precision)
|
|
|
{
|
|
|
( theWrappedObject->setRealNumberPrecision(precision));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextStream::setStatus(QTextStream* theWrappedObject, QTextStream::Status status)
|
|
|
{
|
|
|
( theWrappedObject->setStatus(status));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTextStream::skipWhiteSpace(QTextStream* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->skipWhiteSpace());
|
|
|
}
|
|
|
|
|
|
QTextStream::Status PythonQtWrapper_QTextStream::status(QTextStream* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->status());
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QThreadPool::~PythonQtShell_QThreadPool() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QThreadPool::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;
|
|
|
}
|
|
|
}
|
|
|
QThreadPool::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QThreadPool::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;
|
|
|
}
|
|
|
}
|
|
|
QThreadPool::customEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QThreadPool::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 QThreadPool::event(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QThreadPool::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 QThreadPool::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
void PythonQtShell_QThreadPool::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;
|
|
|
}
|
|
|
}
|
|
|
QThreadPool::timerEvent(arg__1);
|
|
|
}
|
|
|
QThreadPool* PythonQtWrapper_QThreadPool::new_QThreadPool(QObject* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QThreadPool(parent); }
|
|
|
|
|
|
int PythonQtWrapper_QThreadPool::activeThreadCount(QThreadPool* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->activeThreadCount());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QThreadPool::expiryTimeout(QThreadPool* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->expiryTimeout());
|
|
|
}
|
|
|
|
|
|
QThreadPool* PythonQtWrapper_QThreadPool::static_QThreadPool_globalInstance()
|
|
|
{
|
|
|
return (QThreadPool::globalInstance());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QThreadPool::maxThreadCount(QThreadPool* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->maxThreadCount());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QThreadPool::releaseThread(QThreadPool* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->releaseThread());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QThreadPool::reserveThread(QThreadPool* theWrappedObject)
|
|
|
{
|
|
|
( theWrappedObject->reserveThread());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QThreadPool::setExpiryTimeout(QThreadPool* theWrappedObject, int expiryTimeout)
|
|
|
{
|
|
|
( theWrappedObject->setExpiryTimeout(expiryTimeout));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QThreadPool::setMaxThreadCount(QThreadPool* theWrappedObject, int maxThreadCount)
|
|
|
{
|
|
|
( theWrappedObject->setMaxThreadCount(maxThreadCount));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QThreadPool::start(QThreadPool* theWrappedObject, QRunnable* runnable, int priority)
|
|
|
{
|
|
|
( theWrappedObject->start(runnable, priority));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QThreadPool::tryStart(QThreadPool* theWrappedObject, QRunnable* runnable)
|
|
|
{
|
|
|
return ( theWrappedObject->tryStart(runnable));
|
|
|
}
|
|
|
|
|
|
bool PythonQtWrapper_QThreadPool::waitForDone(QThreadPool* theWrappedObject, int msecs)
|
|
|
{
|
|
|
return ( theWrappedObject->waitForDone(msecs));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PythonQtShell_QTimeLine::~PythonQtShell_QTimeLine() {
|
|
|
PythonQtPrivate* priv = PythonQt::priv();
|
|
|
if (priv) { priv->shellClassDeleted(this); }
|
|
|
}
|
|
|
void PythonQtShell_QTimeLine::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;
|
|
|
}
|
|
|
}
|
|
|
QTimeLine::childEvent(arg__1);
|
|
|
}
|
|
|
void PythonQtShell_QTimeLine::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;
|
|
|
}
|
|
|
}
|
|
|
QTimeLine::customEvent(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QTimeLine::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 QTimeLine::event(arg__1);
|
|
|
}
|
|
|
bool PythonQtShell_QTimeLine::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 QTimeLine::eventFilter(arg__1, arg__2);
|
|
|
}
|
|
|
void PythonQtShell_QTimeLine::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;
|
|
|
}
|
|
|
}
|
|
|
QTimeLine::timerEvent(event);
|
|
|
}
|
|
|
qreal PythonQtShell_QTimeLine::valueForTime(int msec) const
|
|
|
{
|
|
|
if (_wrapper) {
|
|
|
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "valueForTime");
|
|
|
PyErr_Clear();
|
|
|
if (obj && !PythonQtSlotFunction_Check(obj)) {
|
|
|
static const char* argumentList[] ={"qreal" , "int"};
|
|
|
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
|
|
qreal returnValue;
|
|
|
void* args[2] = {NULL, (void*)&msec};
|
|
|
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("valueForTime", methodInfo, result);
|
|
|
} else {
|
|
|
returnValue = *((qreal*)args[0]);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (result) { Py_DECREF(result); }
|
|
|
Py_DECREF(obj);
|
|
|
return returnValue;
|
|
|
}
|
|
|
}
|
|
|
return QTimeLine::valueForTime(msec);
|
|
|
}
|
|
|
QTimeLine* PythonQtWrapper_QTimeLine::new_QTimeLine(int duration, QObject* parent)
|
|
|
{
|
|
|
return new PythonQtShell_QTimeLine(duration, parent); }
|
|
|
|
|
|
int PythonQtWrapper_QTimeLine::currentFrame(QTimeLine* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->currentFrame());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTimeLine::currentTime(QTimeLine* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->currentTime());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTimeLine::currentValue(QTimeLine* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->currentValue());
|
|
|
}
|
|
|
|
|
|
QTimeLine::CurveShape PythonQtWrapper_QTimeLine::curveShape(QTimeLine* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->curveShape());
|
|
|
}
|
|
|
|
|
|
QTimeLine::Direction PythonQtWrapper_QTimeLine::direction(QTimeLine* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->direction());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTimeLine::duration(QTimeLine* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->duration());
|
|
|
}
|
|
|
|
|
|
QEasingCurve PythonQtWrapper_QTimeLine::easingCurve(QTimeLine* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->easingCurve());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTimeLine::endFrame(QTimeLine* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->endFrame());
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTimeLine::frameForTime(QTimeLine* theWrappedObject, int msec) const
|
|
|
{
|
|
|
return ( theWrappedObject->frameForTime(msec));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTimeLine::loopCount(QTimeLine* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->loopCount());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTimeLine::setCurveShape(QTimeLine* theWrappedObject, QTimeLine::CurveShape shape)
|
|
|
{
|
|
|
( theWrappedObject->setCurveShape(shape));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTimeLine::setDirection(QTimeLine* theWrappedObject, QTimeLine::Direction direction)
|
|
|
{
|
|
|
( theWrappedObject->setDirection(direction));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTimeLine::setDuration(QTimeLine* theWrappedObject, int duration)
|
|
|
{
|
|
|
( theWrappedObject->setDuration(duration));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTimeLine::setEasingCurve(QTimeLine* theWrappedObject, const QEasingCurve& curve)
|
|
|
{
|
|
|
( theWrappedObject->setEasingCurve(curve));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTimeLine::setEndFrame(QTimeLine* theWrappedObject, int frame)
|
|
|
{
|
|
|
( theWrappedObject->setEndFrame(frame));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTimeLine::setFrameRange(QTimeLine* theWrappedObject, int startFrame, int endFrame)
|
|
|
{
|
|
|
( theWrappedObject->setFrameRange(startFrame, endFrame));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTimeLine::setLoopCount(QTimeLine* theWrappedObject, int count)
|
|
|
{
|
|
|
( theWrappedObject->setLoopCount(count));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTimeLine::setStartFrame(QTimeLine* theWrappedObject, int frame)
|
|
|
{
|
|
|
( theWrappedObject->setStartFrame(frame));
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTimeLine::setUpdateInterval(QTimeLine* theWrappedObject, int interval)
|
|
|
{
|
|
|
( theWrappedObject->setUpdateInterval(interval));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTimeLine::startFrame(QTimeLine* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->startFrame());
|
|
|
}
|
|
|
|
|
|
QTimeLine::State PythonQtWrapper_QTimeLine::state(QTimeLine* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->state());
|
|
|
}
|
|
|
|
|
|
void PythonQtWrapper_QTimeLine::timerEvent(QTimeLine* theWrappedObject, QTimerEvent* event)
|
|
|
{
|
|
|
( ((PythonQtPublicPromoter_QTimeLine*)theWrappedObject)->promoted_timerEvent(event));
|
|
|
}
|
|
|
|
|
|
int PythonQtWrapper_QTimeLine::updateInterval(QTimeLine* theWrappedObject) const
|
|
|
{
|
|
|
return ( theWrappedObject->updateInterval());
|
|
|
}
|
|
|
|
|
|
qreal PythonQtWrapper_QTimeLine::valueForTime(QTimeLine* theWrappedObject, int msec) const
|
|
|
{
|
|
|
return ( ((PythonQtPublicPromoter_QTimeLine*)theWrappedObject)->promoted_valueForTime(msec));
|
|
|
}
|
|
|
|
|
|
|
|
|
|
