##// END OF EJS Templates
GIT_REPOSITORIES » LPP » PythonQt
RSS

Clone from https://github.com/Orochimarufan/PythonQt.git

improved wrapper check to avoid crashes on virtual methods while python object gets deleted...
improved wrapper check to avoid crashes on virtual methods while python object gets deleted git-svn-id: svn://svn.code.sf.net/p/pythonqt/code/trunk@245 ea8d5007-eb21-0410-b261-ccb3ea6e24a9
florianlink - - Load All Authors

File last commit:

r186:69e742701130
r204:7ce280c51c17
Show More
com_trolltech_qt_core0.cpp
7436 lines | 261.8 KiB | text/x-c | CppLexer
/ generated_cpp / com_trolltech_qt_core / com_trolltech_qt_core0.cpp
History | Annotation | Raw |Copy content |Copy permalink
#include "com_trolltech_qt_core0.h"
#include <PythonQtConversion.h>
#include <PythonQtMethodInfo.h>
#include <PythonQtSignalReceiver.h>
#include <QDateTime>
#include <QDir>
#include <QSize>
#include <QStringList>
#include <QVariant>
#include <qabstractanimation.h>
#include <qabstractitemmodel.h>
#include <qabstractstate.h>
#include <qabstracttransition.h>
#include <qanimationgroup.h>
#include <qbuffer.h>
#include <qbytearray.h>
#include <qbytearraymatcher.h>
#include <qcoreapplication.h>
#include <qcoreevent.h>
#include <qcryptographichash.h>
#include <qdatastream.h>
#include <qdatetime.h>
#include <qdir.h>
#include <qdiriterator.h>
#include <qeasingcurve.h>
#include <qelapsedtimer.h>
#include <qeventtransition.h>
#include <qfile.h>
#include <qfileinfo.h>
#include <qfinalstate.h>
#include <qhistorystate.h>
#include <qiodevice.h>
#include <qlibrary.h>
#include <qlist.h>
#include <qmimedata.h>
#include <qobject.h>
#include <qsize.h>
#include <qstate.h>
#include <qstatemachine.h>
#include <qstringlist.h>
#include <qtranslator.h>
PythonQtShell_QAbstractAnimation::~PythonQtShell_QAbstractAnimation() {
PythonQtPrivate* priv = PythonQt::priv();
if (priv) { priv->shellClassDeleted(this); }
}
void PythonQtShell_QAbstractAnimation::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;
}
}
QAbstractAnimation::childEvent(arg__1);
}
void PythonQtShell_QAbstractAnimation::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;
}
}
QAbstractAnimation::customEvent(arg__1);
}
int PythonQtShell_QAbstractAnimation::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 int();
}
bool PythonQtShell_QAbstractAnimation::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 QAbstractAnimation::event(event);
}
bool PythonQtShell_QAbstractAnimation::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 QAbstractAnimation::eventFilter(arg__1, arg__2);
}
void PythonQtShell_QAbstractAnimation::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;
}
}
QAbstractAnimation::timerEvent(arg__1);
}
void PythonQtShell_QAbstractAnimation::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*)&currentTime};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
}
}
}
void PythonQtShell_QAbstractAnimation::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;
}
}
QAbstractAnimation::updateDirection(direction);
}
void PythonQtShell_QAbstractAnimation::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;
}
}
QAbstractAnimation::updateState(newState, oldState);
}
QAbstractAnimation* PythonQtWrapper_QAbstractAnimation::new_QAbstractAnimation(QObject* parent)
{
return new PythonQtShell_QAbstractAnimation(parent); }
int PythonQtWrapper_QAbstractAnimation::currentLoop(QAbstractAnimation* theWrappedObject) const
{
return ( theWrappedObject->currentLoop());
}
int PythonQtWrapper_QAbstractAnimation::currentLoopTime(QAbstractAnimation* theWrappedObject) const
{
return ( theWrappedObject->currentLoopTime());
}
int PythonQtWrapper_QAbstractAnimation::currentTime(QAbstractAnimation* theWrappedObject) const
{
return ( theWrappedObject->currentTime());
}
QAbstractAnimation::Direction PythonQtWrapper_QAbstractAnimation::direction(QAbstractAnimation* theWrappedObject) const
{
return ( theWrappedObject->direction());
}
bool PythonQtWrapper_QAbstractAnimation::event(QAbstractAnimation* theWrappedObject, QEvent* event)
{
return ( ((PythonQtPublicPromoter_QAbstractAnimation*)theWrappedObject)->promoted_event(event));
}
QAnimationGroup* PythonQtWrapper_QAbstractAnimation::group(QAbstractAnimation* theWrappedObject) const
{
return ( theWrappedObject->group());
}
int PythonQtWrapper_QAbstractAnimation::loopCount(QAbstractAnimation* theWrappedObject) const
{
return ( theWrappedObject->loopCount());
}
void PythonQtWrapper_QAbstractAnimation::setDirection(QAbstractAnimation* theWrappedObject, QAbstractAnimation::Direction direction)
{
( theWrappedObject->setDirection(direction));
}
void PythonQtWrapper_QAbstractAnimation::setLoopCount(QAbstractAnimation* theWrappedObject, int loopCount)
{
( theWrappedObject->setLoopCount(loopCount));
}
QAbstractAnimation::State PythonQtWrapper_QAbstractAnimation::state(QAbstractAnimation* theWrappedObject) const
{
return ( theWrappedObject->state());
}
int PythonQtWrapper_QAbstractAnimation::totalDuration(QAbstractAnimation* theWrappedObject) const
{
return ( theWrappedObject->totalDuration());
}
void PythonQtWrapper_QAbstractAnimation::updateDirection(QAbstractAnimation* theWrappedObject, QAbstractAnimation::Direction direction)
{
( ((PythonQtPublicPromoter_QAbstractAnimation*)theWrappedObject)->promoted_updateDirection(direction));
}
void PythonQtWrapper_QAbstractAnimation::updateState(QAbstractAnimation* theWrappedObject, QAbstractAnimation::State newState, QAbstractAnimation::State oldState)
{
( ((PythonQtPublicPromoter_QAbstractAnimation*)theWrappedObject)->promoted_updateState(newState, oldState));
}
PythonQtShell_QAbstractItemModel::~PythonQtShell_QAbstractItemModel() {
PythonQtPrivate* priv = PythonQt::priv();
if (priv) { priv->shellClassDeleted(this); }
}
QModelIndex PythonQtShell_QAbstractItemModel::buddy(const QModelIndex& index) const
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "buddy");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"QModelIndex" , "const QModelIndex&"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
QModelIndex returnValue;
void* args[2] = {NULL, (void*)&index};
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("buddy", methodInfo, result);
} else {
returnValue = *((QModelIndex*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QAbstractItemModel::buddy(index);
}
bool PythonQtShell_QAbstractItemModel::canFetchMore(const QModelIndex& parent) const
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "canFetchMore");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"bool" , "const QModelIndex&"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
bool returnValue;
void* args[2] = {NULL, (void*)&parent};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("canFetchMore", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QAbstractItemModel::canFetchMore(parent);
}
void PythonQtShell_QAbstractItemModel::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;
}
}
QAbstractItemModel::childEvent(arg__1);
}
int PythonQtShell_QAbstractItemModel::columnCount(const QModelIndex& parent) const
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "columnCount");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"int" , "const QModelIndex&"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
int returnValue;
void* args[2] = {NULL, (void*)&parent};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("columnCount", methodInfo, result);
} else {
returnValue = *((int*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return int();
}
void PythonQtShell_QAbstractItemModel::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;
}
}
QAbstractItemModel::customEvent(arg__1);
}
QVariant PythonQtShell_QAbstractItemModel::data(const QModelIndex& index, int role) const
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "data");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"QVariant" , "const QModelIndex&" , "int"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
QVariant returnValue;
void* args[3] = {NULL, (void*)&index, (void*)&role};
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("data", methodInfo, result);
} else {
returnValue = *((QVariant*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QVariant();
}
bool PythonQtShell_QAbstractItemModel::dropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropMimeData");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"bool" , "const QMimeData*" , "Qt::DropAction" , "int" , "int" , "const QModelIndex&"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(6, argumentList);
bool returnValue;
void* args[6] = {NULL, (void*)&data, (void*)&action, (void*)&row, (void*)&column, (void*)&parent};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("dropMimeData", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QAbstractItemModel::dropMimeData(data, action, row, column, parent);
}
bool PythonQtShell_QAbstractItemModel::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 QAbstractItemModel::event(arg__1);
}
bool PythonQtShell_QAbstractItemModel::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 QAbstractItemModel::eventFilter(arg__1, arg__2);
}
void PythonQtShell_QAbstractItemModel::fetchMore(const QModelIndex& parent)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "fetchMore");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"" , "const QModelIndex&"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
void* args[2] = {NULL, (void*)&parent};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
}
}
QAbstractItemModel::fetchMore(parent);
}
Qt::ItemFlags PythonQtShell_QAbstractItemModel::flags(const QModelIndex& index) const
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "flags");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"Qt::ItemFlags" , "const QModelIndex&"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
Qt::ItemFlags returnValue;
void* args[2] = {NULL, (void*)&index};
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("flags", methodInfo, result);
} else {
returnValue = *((Qt::ItemFlags*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QAbstractItemModel::flags(index);
}
bool PythonQtShell_QAbstractItemModel::hasChildren(const QModelIndex& parent) const
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasChildren");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"bool" , "const QModelIndex&"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
bool returnValue;
void* args[2] = {NULL, (void*)&parent};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("hasChildren", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QAbstractItemModel::hasChildren(parent);
}
QVariant PythonQtShell_QAbstractItemModel::headerData(int section, Qt::Orientation orientation, int role) const
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "headerData");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"QVariant" , "int" , "Qt::Orientation" , "int"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
QVariant returnValue;
void* args[4] = {NULL, (void*)&section, (void*)&orientation, (void*)&role};
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("headerData", methodInfo, result);
} else {
returnValue = *((QVariant*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QAbstractItemModel::headerData(section, orientation, role);
}
QModelIndex PythonQtShell_QAbstractItemModel::index(int row, int column, const QModelIndex& parent) const
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "index");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"QModelIndex" , "int" , "int" , "const QModelIndex&"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
QModelIndex returnValue;
void* args[4] = {NULL, (void*)&row, (void*)&column, (void*)&parent};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("index", methodInfo, result);
} else {
returnValue = *((QModelIndex*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QModelIndex();
}
bool PythonQtShell_QAbstractItemModel::insertColumns(int column, int count, const QModelIndex& parent)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "insertColumns");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"bool" , "int" , "int" , "const QModelIndex&"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
bool returnValue;
void* args[4] = {NULL, (void*)&column, (void*)&count, (void*)&parent};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("insertColumns", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QAbstractItemModel::insertColumns(column, count, parent);
}
bool PythonQtShell_QAbstractItemModel::insertRows(int row, int count, const QModelIndex& parent)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "insertRows");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"bool" , "int" , "int" , "const QModelIndex&"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
bool returnValue;
void* args[4] = {NULL, (void*)&row, (void*)&count, (void*)&parent};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("insertRows", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QAbstractItemModel::insertRows(row, count, parent);
}
QMap<int , QVariant > PythonQtShell_QAbstractItemModel::itemData(const QModelIndex& index) const
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "itemData");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"QMap<int , QVariant >" , "const QModelIndex&"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
QMap<int , QVariant > returnValue;
void* args[2] = {NULL, (void*)&index};
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("itemData", methodInfo, result);
} else {
returnValue = *((QMap<int , QVariant >*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QAbstractItemModel::itemData(index);
}
QList<QModelIndex > PythonQtShell_QAbstractItemModel::match(const QModelIndex& start, int role, const QVariant& value, int hits, Qt::MatchFlags flags) const
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "match");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"QList<QModelIndex >" , "const QModelIndex&" , "int" , "const QVariant&" , "int" , "Qt::MatchFlags"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(6, argumentList);
QList<QModelIndex > returnValue;
void* args[6] = {NULL, (void*)&start, (void*)&role, (void*)&value, (void*)&hits, (void*)&flags};
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("match", methodInfo, result);
} else {
returnValue = *((QList<QModelIndex >*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QAbstractItemModel::match(start, role, value, hits, flags);
}
QMimeData* PythonQtShell_QAbstractItemModel::mimeData(const QList<QModelIndex >& indexes) const
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mimeData");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"QMimeData*" , "const QList<QModelIndex >&"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
QMimeData* returnValue;
void* args[2] = {NULL, (void*)&indexes};
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("mimeData", methodInfo, result);
} else {
returnValue = *((QMimeData**)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QAbstractItemModel::mimeData(indexes);
}
QStringList PythonQtShell_QAbstractItemModel::mimeTypes() const
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mimeTypes");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"QStringList"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
QStringList 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("mimeTypes", methodInfo, result);
} else {
returnValue = *((QStringList*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QAbstractItemModel::mimeTypes();
}
QModelIndex PythonQtShell_QAbstractItemModel::parent(const QModelIndex& child) const
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "parent");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"QModelIndex" , "const QModelIndex&"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
QModelIndex returnValue;
void* args[2] = {NULL, (void*)&child};
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("parent", methodInfo, result);
} else {
returnValue = *((QModelIndex*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QModelIndex();
}
bool PythonQtShell_QAbstractItemModel::removeColumns(int column, int count, const QModelIndex& parent)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "removeColumns");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"bool" , "int" , "int" , "const QModelIndex&"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
bool returnValue;
void* args[4] = {NULL, (void*)&column, (void*)&count, (void*)&parent};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("removeColumns", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QAbstractItemModel::removeColumns(column, count, parent);
}
bool PythonQtShell_QAbstractItemModel::removeRows(int row, int count, const QModelIndex& parent)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "removeRows");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"bool" , "int" , "int" , "const QModelIndex&"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
bool returnValue;
void* args[4] = {NULL, (void*)&row, (void*)&count, (void*)&parent};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("removeRows", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QAbstractItemModel::removeRows(row, count, parent);
}
void PythonQtShell_QAbstractItemModel::revert()
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "revert");
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;
}
}
QAbstractItemModel::revert();
}
int PythonQtShell_QAbstractItemModel::rowCount(const QModelIndex& parent) const
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "rowCount");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"int" , "const QModelIndex&"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
int returnValue;
void* args[2] = {NULL, (void*)&parent};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("rowCount", methodInfo, result);
} else {
returnValue = *((int*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return int();
}
bool PythonQtShell_QAbstractItemModel::setData(const QModelIndex& index, const QVariant& value, int role)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setData");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"bool" , "const QModelIndex&" , "const QVariant&" , "int"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
bool returnValue;
void* args[4] = {NULL, (void*)&index, (void*)&value, (void*)&role};
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("setData", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QAbstractItemModel::setData(index, value, role);
}
bool PythonQtShell_QAbstractItemModel::setHeaderData(int section, Qt::Orientation orientation, const QVariant& value, int role)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setHeaderData");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"bool" , "int" , "Qt::Orientation" , "const QVariant&" , "int"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList);
bool returnValue;
void* args[5] = {NULL, (void*)&section, (void*)&orientation, (void*)&value, (void*)&role};
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("setHeaderData", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QAbstractItemModel::setHeaderData(section, orientation, value, role);
}
bool PythonQtShell_QAbstractItemModel::setItemData(const QModelIndex& index, const QMap<int , QVariant >& roles)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setItemData");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"bool" , "const QModelIndex&" , "const QMap<int , QVariant >&"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
bool returnValue;
void* args[3] = {NULL, (void*)&index, (void*)&roles};
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("setItemData", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QAbstractItemModel::setItemData(index, roles);
}
void PythonQtShell_QAbstractItemModel::sort(int column, Qt::SortOrder order)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sort");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"" , "int" , "Qt::SortOrder"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
void* args[3] = {NULL, (void*)&column, (void*)&order};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
}
}
QAbstractItemModel::sort(column, order);
}
QSize PythonQtShell_QAbstractItemModel::span(const QModelIndex& index) const
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "span");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"QSize" , "const QModelIndex&"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
QSize returnValue;
void* args[2] = {NULL, (void*)&index};
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("span", methodInfo, result);
} else {
returnValue = *((QSize*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QAbstractItemModel::span(index);
}
bool PythonQtShell_QAbstractItemModel::submit()
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "submit");
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("submit", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QAbstractItemModel::submit();
}
Qt::DropActions PythonQtShell_QAbstractItemModel::supportedDropActions() const
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "supportedDropActions");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"Qt::DropActions"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
Qt::DropActions 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("supportedDropActions", methodInfo, result);
} else {
returnValue = *((Qt::DropActions*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QAbstractItemModel::supportedDropActions();
}
void PythonQtShell_QAbstractItemModel::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;
}
}
QAbstractItemModel::timerEvent(arg__1);
}
QAbstractItemModel* PythonQtWrapper_QAbstractItemModel::new_QAbstractItemModel(QObject* parent)
{
return new PythonQtShell_QAbstractItemModel(parent); }
QModelIndex PythonQtWrapper_QAbstractItemModel::buddy(QAbstractItemModel* theWrappedObject, const QModelIndex& index) const
{
return ( ((PythonQtPublicPromoter_QAbstractItemModel*)theWrappedObject)->promoted_buddy(index));
}
bool PythonQtWrapper_QAbstractItemModel::canFetchMore(QAbstractItemModel* theWrappedObject, const QModelIndex& parent) const
{
return ( ((PythonQtPublicPromoter_QAbstractItemModel*)theWrappedObject)->promoted_canFetchMore(parent));
}
bool PythonQtWrapper_QAbstractItemModel::dropMimeData(QAbstractItemModel* theWrappedObject, const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent)
{
return ( ((PythonQtPublicPromoter_QAbstractItemModel*)theWrappedObject)->promoted_dropMimeData(data, action, row, column, parent));
}
void PythonQtWrapper_QAbstractItemModel::fetchMore(QAbstractItemModel* theWrappedObject, const QModelIndex& parent)
{
( ((PythonQtPublicPromoter_QAbstractItemModel*)theWrappedObject)->promoted_fetchMore(parent));
}
Qt::ItemFlags PythonQtWrapper_QAbstractItemModel::flags(QAbstractItemModel* theWrappedObject, const QModelIndex& index) const
{
return ( ((PythonQtPublicPromoter_QAbstractItemModel*)theWrappedObject)->promoted_flags(index));
}
bool PythonQtWrapper_QAbstractItemModel::hasChildren(QAbstractItemModel* theWrappedObject, const QModelIndex& parent) const
{
return ( ((PythonQtPublicPromoter_QAbstractItemModel*)theWrappedObject)->promoted_hasChildren(parent));
}
bool PythonQtWrapper_QAbstractItemModel::hasIndex(QAbstractItemModel* theWrappedObject, int row, int column, const QModelIndex& parent) const
{
return ( theWrappedObject->hasIndex(row, column, parent));
}
QVariant PythonQtWrapper_QAbstractItemModel::headerData(QAbstractItemModel* theWrappedObject, int section, Qt::Orientation orientation, int role) const
{
return ( ((PythonQtPublicPromoter_QAbstractItemModel*)theWrappedObject)->promoted_headerData(section, orientation, role));
}
bool PythonQtWrapper_QAbstractItemModel::insertColumn(QAbstractItemModel* theWrappedObject, int column, const QModelIndex& parent)
{
return ( theWrappedObject->insertColumn(column, parent));
}
bool PythonQtWrapper_QAbstractItemModel::insertColumns(QAbstractItemModel* theWrappedObject, int column, int count, const QModelIndex& parent)
{
return ( ((PythonQtPublicPromoter_QAbstractItemModel*)theWrappedObject)->promoted_insertColumns(column, count, parent));
}
bool PythonQtWrapper_QAbstractItemModel::insertRow(QAbstractItemModel* theWrappedObject, int row, const QModelIndex& parent)
{
return ( theWrappedObject->insertRow(row, parent));
}
bool PythonQtWrapper_QAbstractItemModel::insertRows(QAbstractItemModel* theWrappedObject, int row, int count, const QModelIndex& parent)
{
return ( ((PythonQtPublicPromoter_QAbstractItemModel*)theWrappedObject)->promoted_insertRows(row, count, parent));
}
QMap<int , QVariant > PythonQtWrapper_QAbstractItemModel::itemData(QAbstractItemModel* theWrappedObject, const QModelIndex& index) const
{
return ( ((PythonQtPublicPromoter_QAbstractItemModel*)theWrappedObject)->promoted_itemData(index));
}
QList<QModelIndex > PythonQtWrapper_QAbstractItemModel::match(QAbstractItemModel* theWrappedObject, const QModelIndex& start, int role, const QVariant& value, int hits, Qt::MatchFlags flags) const
{
return ( ((PythonQtPublicPromoter_QAbstractItemModel*)theWrappedObject)->promoted_match(start, role, value, hits, flags));
}
QMimeData* PythonQtWrapper_QAbstractItemModel::mimeData(QAbstractItemModel* theWrappedObject, const QList<QModelIndex >& indexes) const
{
return ( ((PythonQtPublicPromoter_QAbstractItemModel*)theWrappedObject)->promoted_mimeData(indexes));
}
QStringList PythonQtWrapper_QAbstractItemModel::mimeTypes(QAbstractItemModel* theWrappedObject) const
{
return ( ((PythonQtPublicPromoter_QAbstractItemModel*)theWrappedObject)->promoted_mimeTypes());
}
QObject* PythonQtWrapper_QAbstractItemModel::parent(QAbstractItemModel* theWrappedObject) const
{
return ( theWrappedObject->parent());
}
bool PythonQtWrapper_QAbstractItemModel::removeColumn(QAbstractItemModel* theWrappedObject, int column, const QModelIndex& parent)
{
return ( theWrappedObject->removeColumn(column, parent));
}
bool PythonQtWrapper_QAbstractItemModel::removeColumns(QAbstractItemModel* theWrappedObject, int column, int count, const QModelIndex& parent)
{
return ( ((PythonQtPublicPromoter_QAbstractItemModel*)theWrappedObject)->promoted_removeColumns(column, count, parent));
}
bool PythonQtWrapper_QAbstractItemModel::removeRow(QAbstractItemModel* theWrappedObject, int row, const QModelIndex& parent)
{
return ( theWrappedObject->removeRow(row, parent));
}
bool PythonQtWrapper_QAbstractItemModel::removeRows(QAbstractItemModel* theWrappedObject, int row, int count, const QModelIndex& parent)
{
return ( ((PythonQtPublicPromoter_QAbstractItemModel*)theWrappedObject)->promoted_removeRows(row, count, parent));
}
void PythonQtWrapper_QAbstractItemModel::revert(QAbstractItemModel* theWrappedObject)
{
( ((PythonQtPublicPromoter_QAbstractItemModel*)theWrappedObject)->promoted_revert());
}
const QHash<int , QByteArray >* PythonQtWrapper_QAbstractItemModel::roleNames(QAbstractItemModel* theWrappedObject) const
{
return &( theWrappedObject->roleNames());
}
bool PythonQtWrapper_QAbstractItemModel::setData(QAbstractItemModel* theWrappedObject, const QModelIndex& index, const QVariant& value, int role)
{
return ( ((PythonQtPublicPromoter_QAbstractItemModel*)theWrappedObject)->promoted_setData(index, value, role));
}
bool PythonQtWrapper_QAbstractItemModel::setHeaderData(QAbstractItemModel* theWrappedObject, int section, Qt::Orientation orientation, const QVariant& value, int role)
{
return ( ((PythonQtPublicPromoter_QAbstractItemModel*)theWrappedObject)->promoted_setHeaderData(section, orientation, value, role));
}
bool PythonQtWrapper_QAbstractItemModel::setItemData(QAbstractItemModel* theWrappedObject, const QModelIndex& index, const QMap<int , QVariant >& roles)
{
return ( ((PythonQtPublicPromoter_QAbstractItemModel*)theWrappedObject)->promoted_setItemData(index, roles));
}
void PythonQtWrapper_QAbstractItemModel::setSupportedDragActions(QAbstractItemModel* theWrappedObject, Qt::DropActions arg__1)
{
( theWrappedObject->setSupportedDragActions(arg__1));
}
QModelIndex PythonQtWrapper_QAbstractItemModel::sibling(QAbstractItemModel* theWrappedObject, int row, int column, const QModelIndex& idx) const
{
return ( theWrappedObject->sibling(row, column, idx));
}
void PythonQtWrapper_QAbstractItemModel::sort(QAbstractItemModel* theWrappedObject, int column, Qt::SortOrder order)
{
( ((PythonQtPublicPromoter_QAbstractItemModel*)theWrappedObject)->promoted_sort(column, order));
}
QSize PythonQtWrapper_QAbstractItemModel::span(QAbstractItemModel* theWrappedObject, const QModelIndex& index) const
{
return ( ((PythonQtPublicPromoter_QAbstractItemModel*)theWrappedObject)->promoted_span(index));
}
bool PythonQtWrapper_QAbstractItemModel::submit(QAbstractItemModel* theWrappedObject)
{
return ( ((PythonQtPublicPromoter_QAbstractItemModel*)theWrappedObject)->promoted_submit());
}
Qt::DropActions PythonQtWrapper_QAbstractItemModel::supportedDragActions(QAbstractItemModel* theWrappedObject) const
{
return ( theWrappedObject->supportedDragActions());
}
Qt::DropActions PythonQtWrapper_QAbstractItemModel::supportedDropActions(QAbstractItemModel* theWrappedObject) const
{
return ( ((PythonQtPublicPromoter_QAbstractItemModel*)theWrappedObject)->promoted_supportedDropActions());
}
PythonQtShell_QAbstractListModel::~PythonQtShell_QAbstractListModel() {
PythonQtPrivate* priv = PythonQt::priv();
if (priv) { priv->shellClassDeleted(this); }
}
QModelIndex PythonQtShell_QAbstractListModel::buddy(const QModelIndex& index) const
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "buddy");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"QModelIndex" , "const QModelIndex&"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
QModelIndex returnValue;
void* args[2] = {NULL, (void*)&index};
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("buddy", methodInfo, result);
} else {
returnValue = *((QModelIndex*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QAbstractListModel::buddy(index);
}
bool PythonQtShell_QAbstractListModel::canFetchMore(const QModelIndex& parent) const
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "canFetchMore");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"bool" , "const QModelIndex&"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
bool returnValue;
void* args[2] = {NULL, (void*)&parent};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("canFetchMore", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QAbstractListModel::canFetchMore(parent);
}
void PythonQtShell_QAbstractListModel::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;
}
}
QAbstractListModel::childEvent(arg__1);
}
void PythonQtShell_QAbstractListModel::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;
}
}
QAbstractListModel::customEvent(arg__1);
}
QVariant PythonQtShell_QAbstractListModel::data(const QModelIndex& index, int role) const
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "data");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"QVariant" , "const QModelIndex&" , "int"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
QVariant returnValue;
void* args[3] = {NULL, (void*)&index, (void*)&role};
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("data", methodInfo, result);
} else {
returnValue = *((QVariant*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QVariant();
}
bool PythonQtShell_QAbstractListModel::dropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "dropMimeData");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"bool" , "const QMimeData*" , "Qt::DropAction" , "int" , "int" , "const QModelIndex&"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(6, argumentList);
bool returnValue;
void* args[6] = {NULL, (void*)&data, (void*)&action, (void*)&row, (void*)&column, (void*)&parent};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("dropMimeData", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QAbstractListModel::dropMimeData(data, action, row, column, parent);
}
bool PythonQtShell_QAbstractListModel::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 QAbstractListModel::event(arg__1);
}
bool PythonQtShell_QAbstractListModel::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 QAbstractListModel::eventFilter(arg__1, arg__2);
}
void PythonQtShell_QAbstractListModel::fetchMore(const QModelIndex& parent)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "fetchMore");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"" , "const QModelIndex&"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
void* args[2] = {NULL, (void*)&parent};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
}
}
QAbstractListModel::fetchMore(parent);
}
Qt::ItemFlags PythonQtShell_QAbstractListModel::flags(const QModelIndex& index) const
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "flags");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"Qt::ItemFlags" , "const QModelIndex&"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
Qt::ItemFlags returnValue;
void* args[2] = {NULL, (void*)&index};
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("flags", methodInfo, result);
} else {
returnValue = *((Qt::ItemFlags*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QAbstractListModel::flags(index);
}
QVariant PythonQtShell_QAbstractListModel::headerData(int section, Qt::Orientation orientation, int role) const
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "headerData");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"QVariant" , "int" , "Qt::Orientation" , "int"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
QVariant returnValue;
void* args[4] = {NULL, (void*)&section, (void*)&orientation, (void*)&role};
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("headerData", methodInfo, result);
} else {
returnValue = *((QVariant*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QAbstractListModel::headerData(section, orientation, role);
}
QModelIndex PythonQtShell_QAbstractListModel::index(int row, int column, const QModelIndex& parent) const
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "index");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"QModelIndex" , "int" , "int" , "const QModelIndex&"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
QModelIndex returnValue;
void* args[4] = {NULL, (void*)&row, (void*)&column, (void*)&parent};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("index", methodInfo, result);
} else {
returnValue = *((QModelIndex*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QAbstractListModel::index(row, column, parent);
}
bool PythonQtShell_QAbstractListModel::insertColumns(int column, int count, const QModelIndex& parent)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "insertColumns");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"bool" , "int" , "int" , "const QModelIndex&"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
bool returnValue;
void* args[4] = {NULL, (void*)&column, (void*)&count, (void*)&parent};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("insertColumns", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QAbstractListModel::insertColumns(column, count, parent);
}
bool PythonQtShell_QAbstractListModel::insertRows(int row, int count, const QModelIndex& parent)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "insertRows");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"bool" , "int" , "int" , "const QModelIndex&"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
bool returnValue;
void* args[4] = {NULL, (void*)&row, (void*)&count, (void*)&parent};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("insertRows", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QAbstractListModel::insertRows(row, count, parent);
}
QMap<int , QVariant > PythonQtShell_QAbstractListModel::itemData(const QModelIndex& index) const
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "itemData");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"QMap<int , QVariant >" , "const QModelIndex&"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
QMap<int , QVariant > returnValue;
void* args[2] = {NULL, (void*)&index};
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("itemData", methodInfo, result);
} else {
returnValue = *((QMap<int , QVariant >*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QAbstractListModel::itemData(index);
}
QList<QModelIndex > PythonQtShell_QAbstractListModel::match(const QModelIndex& start, int role, const QVariant& value, int hits, Qt::MatchFlags flags) const
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "match");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"QList<QModelIndex >" , "const QModelIndex&" , "int" , "const QVariant&" , "int" , "Qt::MatchFlags"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(6, argumentList);
QList<QModelIndex > returnValue;
void* args[6] = {NULL, (void*)&start, (void*)&role, (void*)&value, (void*)&hits, (void*)&flags};
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("match", methodInfo, result);
} else {
returnValue = *((QList<QModelIndex >*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QAbstractListModel::match(start, role, value, hits, flags);
}
QMimeData* PythonQtShell_QAbstractListModel::mimeData(const QList<QModelIndex >& indexes) const
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mimeData");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"QMimeData*" , "const QList<QModelIndex >&"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
QMimeData* returnValue;
void* args[2] = {NULL, (void*)&indexes};
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("mimeData", methodInfo, result);
} else {
returnValue = *((QMimeData**)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QAbstractListModel::mimeData(indexes);
}
QStringList PythonQtShell_QAbstractListModel::mimeTypes() const
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mimeTypes");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"QStringList"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
QStringList 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("mimeTypes", methodInfo, result);
} else {
returnValue = *((QStringList*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QAbstractListModel::mimeTypes();
}
bool PythonQtShell_QAbstractListModel::removeColumns(int column, int count, const QModelIndex& parent)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "removeColumns");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"bool" , "int" , "int" , "const QModelIndex&"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
bool returnValue;
void* args[4] = {NULL, (void*)&column, (void*)&count, (void*)&parent};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("removeColumns", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QAbstractListModel::removeColumns(column, count, parent);
}
bool PythonQtShell_QAbstractListModel::removeRows(int row, int count, const QModelIndex& parent)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "removeRows");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"bool" , "int" , "int" , "const QModelIndex&"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
bool returnValue;
void* args[4] = {NULL, (void*)&row, (void*)&count, (void*)&parent};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("removeRows", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QAbstractListModel::removeRows(row, count, parent);
}
void PythonQtShell_QAbstractListModel::revert()
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "revert");
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;
}
}
QAbstractListModel::revert();
}
int PythonQtShell_QAbstractListModel::rowCount(const QModelIndex& parent) const
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "rowCount");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"int" , "const QModelIndex&"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
int returnValue;
void* args[2] = {NULL, (void*)&parent};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("rowCount", methodInfo, result);
} else {
returnValue = *((int*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return int();
}
bool PythonQtShell_QAbstractListModel::setData(const QModelIndex& index, const QVariant& value, int role)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setData");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"bool" , "const QModelIndex&" , "const QVariant&" , "int"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
bool returnValue;
void* args[4] = {NULL, (void*)&index, (void*)&value, (void*)&role};
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("setData", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QAbstractListModel::setData(index, value, role);
}
bool PythonQtShell_QAbstractListModel::setHeaderData(int section, Qt::Orientation orientation, const QVariant& value, int role)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setHeaderData");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"bool" , "int" , "Qt::Orientation" , "const QVariant&" , "int"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList);
bool returnValue;
void* args[5] = {NULL, (void*)&section, (void*)&orientation, (void*)&value, (void*)&role};
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("setHeaderData", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QAbstractListModel::setHeaderData(section, orientation, value, role);
}
bool PythonQtShell_QAbstractListModel::setItemData(const QModelIndex& index, const QMap<int , QVariant >& roles)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setItemData");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"bool" , "const QModelIndex&" , "const QMap<int , QVariant >&"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
bool returnValue;
void* args[3] = {NULL, (void*)&index, (void*)&roles};
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("setItemData", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QAbstractListModel::setItemData(index, roles);
}
void PythonQtShell_QAbstractListModel::sort(int column, Qt::SortOrder order)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sort");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"" , "int" , "Qt::SortOrder"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
void* args[3] = {NULL, (void*)&column, (void*)&order};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
}
}
QAbstractListModel::sort(column, order);
}
QSize PythonQtShell_QAbstractListModel::span(const QModelIndex& index) const
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "span");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"QSize" , "const QModelIndex&"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
QSize returnValue;
void* args[2] = {NULL, (void*)&index};
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("span", methodInfo, result);
} else {
returnValue = *((QSize*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QAbstractListModel::span(index);
}
bool PythonQtShell_QAbstractListModel::submit()
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "submit");
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("submit", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QAbstractListModel::submit();
}
Qt::DropActions PythonQtShell_QAbstractListModel::supportedDropActions() const
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "supportedDropActions");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"Qt::DropActions"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
Qt::DropActions 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("supportedDropActions", methodInfo, result);
} else {
returnValue = *((Qt::DropActions*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QAbstractListModel::supportedDropActions();
}
void PythonQtShell_QAbstractListModel::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;
}
}
QAbstractListModel::timerEvent(arg__1);
}
QAbstractListModel* PythonQtWrapper_QAbstractListModel::new_QAbstractListModel(QObject* parent)
{
return new PythonQtShell_QAbstractListModel(parent); }
bool PythonQtWrapper_QAbstractListModel::dropMimeData(QAbstractListModel* theWrappedObject, const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent)
{
return ( ((PythonQtPublicPromoter_QAbstractListModel*)theWrappedObject)->promoted_dropMimeData(data, action, row, column, parent));
}
QModelIndex PythonQtWrapper_QAbstractListModel::index(QAbstractListModel* theWrappedObject, int row, int column, const QModelIndex& parent) const
{
return ( ((PythonQtPublicPromoter_QAbstractListModel*)theWrappedObject)->promoted_index(row, column, parent));
}
PythonQtShell_QAbstractState::~PythonQtShell_QAbstractState() {
PythonQtPrivate* priv = PythonQt::priv();
if (priv) { priv->shellClassDeleted(this); }
}
void PythonQtShell_QAbstractState::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;
}
}
QAbstractState::childEvent(arg__1);
}
void PythonQtShell_QAbstractState::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;
}
}
QAbstractState::customEvent(arg__1);
}
bool PythonQtShell_QAbstractState::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 QAbstractState::event(e);
}
bool PythonQtShell_QAbstractState::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 QAbstractState::eventFilter(arg__1, arg__2);
}
void PythonQtShell_QAbstractState::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;
}
}
}
void PythonQtShell_QAbstractState::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;
}
}
}
void PythonQtShell_QAbstractState::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;
}
}
QAbstractState::timerEvent(arg__1);
}
bool PythonQtWrapper_QAbstractState::event(QAbstractState* theWrappedObject, QEvent* e)
{
return ( ((PythonQtPublicPromoter_QAbstractState*)theWrappedObject)->promoted_event(e));
}
QStateMachine* PythonQtWrapper_QAbstractState::machine(QAbstractState* theWrappedObject) const
{
return ( theWrappedObject->machine());
}
QState* PythonQtWrapper_QAbstractState::parentState(QAbstractState* theWrappedObject) const
{
return ( theWrappedObject->parentState());
}
PythonQtShell_QAbstractTransition::~PythonQtShell_QAbstractTransition() {
PythonQtPrivate* priv = PythonQt::priv();
if (priv) { priv->shellClassDeleted(this); }
}
void PythonQtShell_QAbstractTransition::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;
}
}
QAbstractTransition::childEvent(arg__1);
}
void PythonQtShell_QAbstractTransition::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;
}
}
QAbstractTransition::customEvent(arg__1);
}
bool PythonQtShell_QAbstractTransition::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 QAbstractTransition::event(e);
}
bool PythonQtShell_QAbstractTransition::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 QAbstractTransition::eventFilter(arg__1, arg__2);
}
bool PythonQtShell_QAbstractTransition::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 bool();
}
void PythonQtShell_QAbstractTransition::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;
}
}
}
void PythonQtShell_QAbstractTransition::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;
}
}
QAbstractTransition::timerEvent(arg__1);
}
QAbstractTransition* PythonQtWrapper_QAbstractTransition::new_QAbstractTransition(QState* sourceState)
{
return new PythonQtShell_QAbstractTransition(sourceState); }
void PythonQtWrapper_QAbstractTransition::addAnimation(QAbstractTransition* theWrappedObject, QAbstractAnimation* animation)
{
( theWrappedObject->addAnimation(animation));
}
QList<QAbstractAnimation* > PythonQtWrapper_QAbstractTransition::animations(QAbstractTransition* theWrappedObject) const
{
return ( theWrappedObject->animations());
}
bool PythonQtWrapper_QAbstractTransition::event(QAbstractTransition* theWrappedObject, QEvent* e)
{
return ( ((PythonQtPublicPromoter_QAbstractTransition*)theWrappedObject)->promoted_event(e));
}
QStateMachine* PythonQtWrapper_QAbstractTransition::machine(QAbstractTransition* theWrappedObject) const
{
return ( theWrappedObject->machine());
}
void PythonQtWrapper_QAbstractTransition::removeAnimation(QAbstractTransition* theWrappedObject, QAbstractAnimation* animation)
{
( theWrappedObject->removeAnimation(animation));
}
void PythonQtWrapper_QAbstractTransition::setTargetState(QAbstractTransition* theWrappedObject, QAbstractState* target)
{
( theWrappedObject->setTargetState(target));
}
void PythonQtWrapper_QAbstractTransition::setTargetStates(QAbstractTransition* theWrappedObject, const QList<QAbstractState* >& targets)
{
( theWrappedObject->setTargetStates(targets));
}
QState* PythonQtWrapper_QAbstractTransition::sourceState(QAbstractTransition* theWrappedObject) const
{
return ( theWrappedObject->sourceState());
}
QAbstractState* PythonQtWrapper_QAbstractTransition::targetState(QAbstractTransition* theWrappedObject) const
{
return ( theWrappedObject->targetState());
}
QList<QAbstractState* > PythonQtWrapper_QAbstractTransition::targetStates(QAbstractTransition* theWrappedObject) const
{
return ( theWrappedObject->targetStates());
}
PythonQtShell_QAnimationGroup::~PythonQtShell_QAnimationGroup() {
PythonQtPrivate* priv = PythonQt::priv();
if (priv) { priv->shellClassDeleted(this); }
}
void PythonQtShell_QAnimationGroup::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;
}
}
QAnimationGroup::childEvent(arg__1);
}
void PythonQtShell_QAnimationGroup::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;
}
}
QAnimationGroup::customEvent(arg__1);
}
int PythonQtShell_QAnimationGroup::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 int();
}
bool PythonQtShell_QAnimationGroup::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 QAnimationGroup::event(event);
}
bool PythonQtShell_QAnimationGroup::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 QAnimationGroup::eventFilter(arg__1, arg__2);
}
void PythonQtShell_QAnimationGroup::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;
}
}
QAnimationGroup::timerEvent(arg__1);
}
void PythonQtShell_QAnimationGroup::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*)&currentTime};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return;
}
}
}
void PythonQtShell_QAnimationGroup::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;
}
}
QAnimationGroup::updateDirection(direction);
}
void PythonQtShell_QAnimationGroup::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;
}
}
QAnimationGroup::updateState(newState, oldState);
}
QAnimationGroup* PythonQtWrapper_QAnimationGroup::new_QAnimationGroup(QObject* parent)
{
return new PythonQtShell_QAnimationGroup(parent); }
void PythonQtWrapper_QAnimationGroup::addAnimation(QAnimationGroup* theWrappedObject, QAbstractAnimation* animation)
{
( theWrappedObject->addAnimation(animation));
}
QAbstractAnimation* PythonQtWrapper_QAnimationGroup::animationAt(QAnimationGroup* theWrappedObject, int index) const
{
return ( theWrappedObject->animationAt(index));
}
int PythonQtWrapper_QAnimationGroup::animationCount(QAnimationGroup* theWrappedObject) const
{
return ( theWrappedObject->animationCount());
}
void PythonQtWrapper_QAnimationGroup::clear(QAnimationGroup* theWrappedObject)
{
( theWrappedObject->clear());
}
bool PythonQtWrapper_QAnimationGroup::event(QAnimationGroup* theWrappedObject, QEvent* event)
{
return ( ((PythonQtPublicPromoter_QAnimationGroup*)theWrappedObject)->promoted_event(event));
}
int PythonQtWrapper_QAnimationGroup::indexOfAnimation(QAnimationGroup* theWrappedObject, QAbstractAnimation* animation) const
{
return ( theWrappedObject->indexOfAnimation(animation));
}
void PythonQtWrapper_QAnimationGroup::insertAnimation(QAnimationGroup* theWrappedObject, int index, QAbstractAnimation* animation)
{
( theWrappedObject->insertAnimation(index, animation));
}
void PythonQtWrapper_QAnimationGroup::removeAnimation(QAnimationGroup* theWrappedObject, QAbstractAnimation* animation)
{
( theWrappedObject->removeAnimation(animation));
}
QAbstractAnimation* PythonQtWrapper_QAnimationGroup::takeAnimation(QAnimationGroup* theWrappedObject, int index)
{
return ( theWrappedObject->takeAnimation(index));
}
QBasicTimer* PythonQtWrapper_QBasicTimer::new_QBasicTimer()
{
return new QBasicTimer(); }
bool PythonQtWrapper_QBasicTimer::isActive(QBasicTimer* theWrappedObject) const
{
return ( theWrappedObject->isActive());
}
void PythonQtWrapper_QBasicTimer::start(QBasicTimer* theWrappedObject, int msec, QObject* obj)
{
( theWrappedObject->start(msec, obj));
}
void PythonQtWrapper_QBasicTimer::stop(QBasicTimer* theWrappedObject)
{
( theWrappedObject->stop());
}
int PythonQtWrapper_QBasicTimer::timerId(QBasicTimer* theWrappedObject) const
{
return ( theWrappedObject->timerId());
}
PythonQtShell_QBuffer::~PythonQtShell_QBuffer() {
PythonQtPrivate* priv = PythonQt::priv();
if (priv) { priv->shellClassDeleted(this); }
}
bool PythonQtShell_QBuffer::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 QBuffer::atEnd();
}
qint64 PythonQtShell_QBuffer::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 QBuffer::bytesAvailable();
}
qint64 PythonQtShell_QBuffer::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 QBuffer::bytesToWrite();
}
bool PythonQtShell_QBuffer::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 QBuffer::canReadLine();
}
void PythonQtShell_QBuffer::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;
}
}
QBuffer::childEvent(arg__1);
}
void PythonQtShell_QBuffer::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;
}
}
QBuffer::close();
}
void PythonQtShell_QBuffer::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;
}
}
QBuffer::customEvent(arg__1);
}
bool PythonQtShell_QBuffer::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 QBuffer::event(arg__1);
}
bool PythonQtShell_QBuffer::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 QBuffer::eventFilter(arg__1, arg__2);
}
bool PythonQtShell_QBuffer::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 QBuffer::isSequential();
}
bool PythonQtShell_QBuffer::open(QIODevice::OpenMode openMode)
{
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*)&openMode};
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 QBuffer::open(openMode);
}
qint64 PythonQtShell_QBuffer::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 QBuffer::pos();
}
qint64 PythonQtShell_QBuffer::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 QBuffer::readData(data, maxlen);
}
qint64 PythonQtShell_QBuffer::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 QBuffer::readLineData(data, maxlen);
}
bool PythonQtShell_QBuffer::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 QBuffer::reset();
}
bool PythonQtShell_QBuffer::seek(qint64 off)
{
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*)&off};
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 QBuffer::seek(off);
}
qint64 PythonQtShell_QBuffer::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 QBuffer::size();
}
void PythonQtShell_QBuffer::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;
}
}
QBuffer::timerEvent(arg__1);
}
bool PythonQtShell_QBuffer::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 QBuffer::waitForBytesWritten(msecs);
}
bool PythonQtShell_QBuffer::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 QBuffer::waitForReadyRead(msecs);
}
qint64 PythonQtShell_QBuffer::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 QBuffer::writeData(data, len);
}
QBuffer* PythonQtWrapper_QBuffer::new_QBuffer(QByteArray* buf, QObject* parent)
{
return new PythonQtShell_QBuffer(buf, parent); }
QBuffer* PythonQtWrapper_QBuffer::new_QBuffer(QObject* parent)
{
return new PythonQtShell_QBuffer(parent); }
bool PythonQtWrapper_QBuffer::atEnd(QBuffer* theWrappedObject) const
{
return ( ((PythonQtPublicPromoter_QBuffer*)theWrappedObject)->promoted_atEnd());
}
bool PythonQtWrapper_QBuffer::canReadLine(QBuffer* theWrappedObject) const
{
return ( ((PythonQtPublicPromoter_QBuffer*)theWrappedObject)->promoted_canReadLine());
}
void PythonQtWrapper_QBuffer::close(QBuffer* theWrappedObject)
{
( ((PythonQtPublicPromoter_QBuffer*)theWrappedObject)->promoted_close());
}
bool PythonQtWrapper_QBuffer::open(QBuffer* theWrappedObject, QIODevice::OpenMode openMode)
{
return ( ((PythonQtPublicPromoter_QBuffer*)theWrappedObject)->promoted_open(openMode));
}
qint64 PythonQtWrapper_QBuffer::pos(QBuffer* theWrappedObject) const
{
return ( ((PythonQtPublicPromoter_QBuffer*)theWrappedObject)->promoted_pos());
}
qint64 PythonQtWrapper_QBuffer::readData(QBuffer* theWrappedObject, char* data, qint64 maxlen)
{
return ( ((PythonQtPublicPromoter_QBuffer*)theWrappedObject)->promoted_readData(data, maxlen));
}
bool PythonQtWrapper_QBuffer::seek(QBuffer* theWrappedObject, qint64 off)
{
return ( ((PythonQtPublicPromoter_QBuffer*)theWrappedObject)->promoted_seek(off));
}
void PythonQtWrapper_QBuffer::setBuffer(QBuffer* theWrappedObject, QByteArray* a)
{
( theWrappedObject->setBuffer(a));
}
void PythonQtWrapper_QBuffer::setData(QBuffer* theWrappedObject, const QByteArray& data)
{
( theWrappedObject->setData(data));
}
qint64 PythonQtWrapper_QBuffer::size(QBuffer* theWrappedObject) const
{
return ( ((PythonQtPublicPromoter_QBuffer*)theWrappedObject)->promoted_size());
}
qint64 PythonQtWrapper_QBuffer::writeData(QBuffer* theWrappedObject, const char* data, qint64 len)
{
return ( ((PythonQtPublicPromoter_QBuffer*)theWrappedObject)->promoted_writeData(data, len));
}
QByteArrayMatcher* PythonQtWrapper_QByteArrayMatcher::new_QByteArrayMatcher()
{
return new QByteArrayMatcher(); }
QByteArrayMatcher* PythonQtWrapper_QByteArrayMatcher::new_QByteArrayMatcher(const QByteArray& pattern)
{
return new QByteArrayMatcher(pattern); }
QByteArrayMatcher* PythonQtWrapper_QByteArrayMatcher::new_QByteArrayMatcher(const QByteArrayMatcher& other)
{
return new QByteArrayMatcher(other); }
QByteArrayMatcher* PythonQtWrapper_QByteArrayMatcher::new_QByteArrayMatcher(const char* pattern, int length)
{
return new QByteArrayMatcher(pattern, length); }
int PythonQtWrapper_QByteArrayMatcher::indexIn(QByteArrayMatcher* theWrappedObject, const QByteArray& ba, int from) const
{
return ( theWrappedObject->indexIn(ba, from));
}
int PythonQtWrapper_QByteArrayMatcher::indexIn(QByteArrayMatcher* theWrappedObject, const char* str, int len, int from) const
{
return ( theWrappedObject->indexIn(str, len, from));
}
QByteArray PythonQtWrapper_QByteArrayMatcher::pattern(QByteArrayMatcher* theWrappedObject) const
{
return ( theWrappedObject->pattern());
}
void PythonQtWrapper_QByteArrayMatcher::setPattern(QByteArrayMatcher* theWrappedObject, const QByteArray& pattern)
{
( theWrappedObject->setPattern(pattern));
}
PythonQtShell_QChildEvent::~PythonQtShell_QChildEvent() {
PythonQtPrivate* priv = PythonQt::priv();
if (priv) { priv->shellClassDeleted(this); }
}
QChildEvent* PythonQtWrapper_QChildEvent::new_QChildEvent(QEvent::Type type, QObject* child)
{
return new PythonQtShell_QChildEvent(type, child); }
bool PythonQtWrapper_QChildEvent::added(QChildEvent* theWrappedObject) const
{
return ( theWrappedObject->added());
}
QObject* PythonQtWrapper_QChildEvent::child(QChildEvent* theWrappedObject) const
{
return ( theWrappedObject->child());
}
bool PythonQtWrapper_QChildEvent::polished(QChildEvent* theWrappedObject) const
{
return ( theWrappedObject->polished());
}
bool PythonQtWrapper_QChildEvent::removed(QChildEvent* theWrappedObject) const
{
return ( theWrappedObject->removed());
}
PythonQtShell_QCoreApplication::~PythonQtShell_QCoreApplication() {
PythonQtPrivate* priv = PythonQt::priv();
if (priv) { priv->shellClassDeleted(this); }
}
void PythonQtShell_QCoreApplication::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;
}
}
QCoreApplication::childEvent(arg__1);
}
void PythonQtShell_QCoreApplication::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;
}
}
QCoreApplication::customEvent(arg__1);
}
bool PythonQtShell_QCoreApplication::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 QCoreApplication::event(arg__1);
}
bool PythonQtShell_QCoreApplication::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 QCoreApplication::eventFilter(arg__1, arg__2);
}
bool PythonQtShell_QCoreApplication::notify(QObject* arg__1, QEvent* arg__2)
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "notify");
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("notify", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QCoreApplication::notify(arg__1, arg__2);
}
void PythonQtShell_QCoreApplication::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;
}
}
QCoreApplication::timerEvent(arg__1);
}
void PythonQtWrapper_QCoreApplication::static_QCoreApplication_addLibraryPath(const QString& arg__1)
{
(QCoreApplication::addLibraryPath(arg__1));
}
QString PythonQtWrapper_QCoreApplication::static_QCoreApplication_applicationDirPath()
{
return (QCoreApplication::applicationDirPath());
}
QString PythonQtWrapper_QCoreApplication::static_QCoreApplication_applicationFilePath()
{
return (QCoreApplication::applicationFilePath());
}
QString PythonQtWrapper_QCoreApplication::static_QCoreApplication_applicationName()
{
return (QCoreApplication::applicationName());
}
qint64 PythonQtWrapper_QCoreApplication::static_QCoreApplication_applicationPid()
{
return (QCoreApplication::applicationPid());
}
QString PythonQtWrapper_QCoreApplication::static_QCoreApplication_applicationVersion()
{
return (QCoreApplication::applicationVersion());
}
bool PythonQtWrapper_QCoreApplication::static_QCoreApplication_closingDown()
{
return (QCoreApplication::closingDown());
}
bool PythonQtWrapper_QCoreApplication::event(QCoreApplication* theWrappedObject, QEvent* arg__1)
{
return ( ((PythonQtPublicPromoter_QCoreApplication*)theWrappedObject)->promoted_event(arg__1));
}
int PythonQtWrapper_QCoreApplication::static_QCoreApplication_exec()
{
return (QCoreApplication::exec());
}
void PythonQtWrapper_QCoreApplication::static_QCoreApplication_exit(int retcode)
{
(QCoreApplication::exit(retcode));
}
void PythonQtWrapper_QCoreApplication::static_QCoreApplication_flush()
{
(QCoreApplication::flush());
}
bool PythonQtWrapper_QCoreApplication::static_QCoreApplication_hasPendingEvents()
{
return (QCoreApplication::hasPendingEvents());
}
void PythonQtWrapper_QCoreApplication::static_QCoreApplication_installTranslator(QTranslator* messageFile)
{
(QCoreApplication::installTranslator(messageFile));
}
QCoreApplication* PythonQtWrapper_QCoreApplication::static_QCoreApplication_instance()
{
return (QCoreApplication::instance());
}
QStringList PythonQtWrapper_QCoreApplication::static_QCoreApplication_libraryPaths()
{
return (QCoreApplication::libraryPaths());
}
bool PythonQtWrapper_QCoreApplication::notify(QCoreApplication* theWrappedObject, QObject* arg__1, QEvent* arg__2)
{
return ( ((PythonQtPublicPromoter_QCoreApplication*)theWrappedObject)->promoted_notify(arg__1, arg__2));
}
QString PythonQtWrapper_QCoreApplication::static_QCoreApplication_organizationDomain()
{
return (QCoreApplication::organizationDomain());
}
QString PythonQtWrapper_QCoreApplication::static_QCoreApplication_organizationName()
{
return (QCoreApplication::organizationName());
}
void PythonQtWrapper_QCoreApplication::static_QCoreApplication_postEvent(QObject* receiver, QEvent* event)
{
(QCoreApplication::postEvent(receiver, event));
}
void PythonQtWrapper_QCoreApplication::static_QCoreApplication_postEvent(QObject* receiver, QEvent* event, int priority)
{
(QCoreApplication::postEvent(receiver, event, priority));
}
void PythonQtWrapper_QCoreApplication::static_QCoreApplication_processEvents(QEventLoop::ProcessEventsFlags flags)
{
(QCoreApplication::processEvents(flags));
}
void PythonQtWrapper_QCoreApplication::static_QCoreApplication_processEvents(QEventLoop::ProcessEventsFlags flags, int maxtime)
{
(QCoreApplication::processEvents(flags, maxtime));
}
void PythonQtWrapper_QCoreApplication::static_QCoreApplication_removeLibraryPath(const QString& arg__1)
{
(QCoreApplication::removeLibraryPath(arg__1));
}
void PythonQtWrapper_QCoreApplication::static_QCoreApplication_removePostedEvents(QObject* receiver)
{
(QCoreApplication::removePostedEvents(receiver));
}
void PythonQtWrapper_QCoreApplication::static_QCoreApplication_removePostedEvents(QObject* receiver, int eventType)
{
(QCoreApplication::removePostedEvents(receiver, eventType));
}
void PythonQtWrapper_QCoreApplication::static_QCoreApplication_removeTranslator(QTranslator* messageFile)
{
(QCoreApplication::removeTranslator(messageFile));
}
bool PythonQtWrapper_QCoreApplication::static_QCoreApplication_sendEvent(QObject* receiver, QEvent* event)
{
return (QCoreApplication::sendEvent(receiver, event));
}
void PythonQtWrapper_QCoreApplication::static_QCoreApplication_sendPostedEvents()
{
(QCoreApplication::sendPostedEvents());
}
void PythonQtWrapper_QCoreApplication::static_QCoreApplication_sendPostedEvents(QObject* receiver, int event_type)
{
(QCoreApplication::sendPostedEvents(receiver, event_type));
}
void PythonQtWrapper_QCoreApplication::static_QCoreApplication_setApplicationName(const QString& application)
{
(QCoreApplication::setApplicationName(application));
}
void PythonQtWrapper_QCoreApplication::static_QCoreApplication_setApplicationVersion(const QString& version)
{
(QCoreApplication::setApplicationVersion(version));
}
void PythonQtWrapper_QCoreApplication::static_QCoreApplication_setAttribute(Qt::ApplicationAttribute attribute, bool on)
{
(QCoreApplication::setAttribute(attribute, on));
}
void PythonQtWrapper_QCoreApplication::static_QCoreApplication_setLibraryPaths(const QStringList& arg__1)
{
(QCoreApplication::setLibraryPaths(arg__1));
}
void PythonQtWrapper_QCoreApplication::static_QCoreApplication_setOrganizationDomain(const QString& orgDomain)
{
(QCoreApplication::setOrganizationDomain(orgDomain));
}
void PythonQtWrapper_QCoreApplication::static_QCoreApplication_setOrganizationName(const QString& orgName)
{
(QCoreApplication::setOrganizationName(orgName));
}
bool PythonQtWrapper_QCoreApplication::static_QCoreApplication_startingUp()
{
return (QCoreApplication::startingUp());
}
bool PythonQtWrapper_QCoreApplication::static_QCoreApplication_testAttribute(Qt::ApplicationAttribute attribute)
{
return (QCoreApplication::testAttribute(attribute));
}
QString PythonQtWrapper_QCoreApplication::static_QCoreApplication_translate(const char* context, const char* key, const char* disambiguation, QCoreApplication::Encoding encoding)
{
return (QCoreApplication::translate(context, key, disambiguation, encoding));
}
QString PythonQtWrapper_QCoreApplication::static_QCoreApplication_translate(const char* context, const char* key, const char* disambiguation, QCoreApplication::Encoding encoding, int n)
{
return (QCoreApplication::translate(context, key, disambiguation, encoding, n));
}
QCryptographicHash* PythonQtWrapper_QCryptographicHash::new_QCryptographicHash(QCryptographicHash::Algorithm method)
{
return new QCryptographicHash(method); }
void PythonQtWrapper_QCryptographicHash::addData(QCryptographicHash* theWrappedObject, const QByteArray& data)
{
( theWrappedObject->addData(data));
}
QByteArray PythonQtWrapper_QCryptographicHash::static_QCryptographicHash_hash(const QByteArray& data, QCryptographicHash::Algorithm method)
{
return (QCryptographicHash::hash(data, method));
}
void PythonQtWrapper_QCryptographicHash::reset(QCryptographicHash* theWrappedObject)
{
( theWrappedObject->reset());
}
QByteArray PythonQtWrapper_QCryptographicHash::result(QCryptographicHash* theWrappedObject) const
{
return ( theWrappedObject->result());
}
PythonQtShell_QDataStream::~PythonQtShell_QDataStream() {
PythonQtPrivate* priv = PythonQt::priv();
if (priv) { priv->shellClassDeleted(this); }
}
QDataStream* PythonQtWrapper_QDataStream::new_QDataStream()
{
return new PythonQtShell_QDataStream(); }
QDataStream* PythonQtWrapper_QDataStream::new_QDataStream(QByteArray* arg__1, QIODevice::OpenMode flags)
{
return new PythonQtShell_QDataStream(arg__1, flags); }
QDataStream* PythonQtWrapper_QDataStream::new_QDataStream(QIODevice* arg__1)
{
return new PythonQtShell_QDataStream(arg__1); }
QDataStream* PythonQtWrapper_QDataStream::new_QDataStream(const QByteArray& arg__1)
{
return new PythonQtShell_QDataStream(arg__1); }
bool PythonQtWrapper_QDataStream::atEnd(QDataStream* theWrappedObject) const
{
return ( theWrappedObject->atEnd());
}
QIODevice* PythonQtWrapper_QDataStream::device(QDataStream* theWrappedObject) const
{
return ( theWrappedObject->device());
}
QDataStream::FloatingPointPrecision PythonQtWrapper_QDataStream::floatingPointPrecision(QDataStream* theWrappedObject) const
{
return ( theWrappedObject->floatingPointPrecision());
}
QDataStream* PythonQtWrapper_QDataStream::writeBoolean(QDataStream* theWrappedObject, bool i)
{
return &( (*theWrappedObject) <<i);
}
QDataStream* PythonQtWrapper_QDataStream::writeDouble(QDataStream* theWrappedObject, double f)
{
return &( (*theWrappedObject) <<f);
}
QDataStream* PythonQtWrapper_QDataStream::writeFloat(QDataStream* theWrappedObject, float f)
{
return &( (*theWrappedObject) <<f);
}
QDataStream* PythonQtWrapper_QDataStream::writeInt(QDataStream* theWrappedObject, int i)
{
return &( (*theWrappedObject) <<i);
}
QDataStream* PythonQtWrapper_QDataStream::writeLongLong(QDataStream* theWrappedObject, qint64 i)
{
return &( (*theWrappedObject) <<i);
}
QDataStream* PythonQtWrapper_QDataStream::writeShort(QDataStream* theWrappedObject, short i)
{
return &( (*theWrappedObject) <<i);
}
QDataStream* PythonQtWrapper_QDataStream::readBoolean(QDataStream* theWrappedObject, bool& i)
{
return &( (*theWrappedObject) >>i);
}
QDataStream* PythonQtWrapper_QDataStream::readDouble(QDataStream* theWrappedObject, double& f)
{
return &( (*theWrappedObject) >>f);
}
QDataStream* PythonQtWrapper_QDataStream::readFloat(QDataStream* theWrappedObject, float& f)
{
return &( (*theWrappedObject) >>f);
}
QDataStream* PythonQtWrapper_QDataStream::readInt(QDataStream* theWrappedObject, int& i)
{
return &( (*theWrappedObject) >>i);
}
QDataStream* PythonQtWrapper_QDataStream::readLongLong(QDataStream* theWrappedObject, qint64& i)
{
return &( (*theWrappedObject) >>i);
}
QDataStream* PythonQtWrapper_QDataStream::readShort(QDataStream* theWrappedObject, short& i)
{
return &( (*theWrappedObject) >>i);
}
QDataStream* PythonQtWrapper_QDataStream::readUShort(QDataStream* theWrappedObject, unsigned short& i)
{
return &( (*theWrappedObject) >>i);
}
void PythonQtWrapper_QDataStream::resetStatus(QDataStream* theWrappedObject)
{
( theWrappedObject->resetStatus());
}
void PythonQtWrapper_QDataStream::setDevice(QDataStream* theWrappedObject, QIODevice* arg__1)
{
( theWrappedObject->setDevice(arg__1));
}
void PythonQtWrapper_QDataStream::setFloatingPointPrecision(QDataStream* theWrappedObject, QDataStream::FloatingPointPrecision precision)
{
( theWrappedObject->setFloatingPointPrecision(precision));
}
void PythonQtWrapper_QDataStream::setStatus(QDataStream* theWrappedObject, QDataStream::Status status)
{
( theWrappedObject->setStatus(status));
}
void PythonQtWrapper_QDataStream::setVersion(QDataStream* theWrappedObject, int arg__1)
{
( theWrappedObject->setVersion(arg__1));
}
int PythonQtWrapper_QDataStream::skipRawData(QDataStream* theWrappedObject, int len)
{
return ( theWrappedObject->skipRawData(len));
}
QDataStream::Status PythonQtWrapper_QDataStream::status(QDataStream* theWrappedObject) const
{
return ( theWrappedObject->status());
}
void PythonQtWrapper_QDataStream::unsetDevice(QDataStream* theWrappedObject)
{
( theWrappedObject->unsetDevice());
}
int PythonQtWrapper_QDataStream::version(QDataStream* theWrappedObject) const
{
return ( theWrappedObject->version());
}
QDir* PythonQtWrapper_QDir::new_QDir(const QDir& arg__1)
{
return new QDir(arg__1); }
QDir* PythonQtWrapper_QDir::new_QDir(const QString& path)
{
return new QDir(path); }
QDir* PythonQtWrapper_QDir::new_QDir(const QString& path, const QString& nameFilter, QDir::SortFlags sort, QDir::Filters filter)
{
return new QDir(path, nameFilter, sort, filter); }
QString PythonQtWrapper_QDir::absoluteFilePath(QDir* theWrappedObject, const QString& fileName) const
{
return ( theWrappedObject->absoluteFilePath(fileName));
}
QString PythonQtWrapper_QDir::absolutePath(QDir* theWrappedObject) const
{
return ( theWrappedObject->absolutePath());
}
void PythonQtWrapper_QDir::static_QDir_addSearchPath(const QString& prefix, const QString& path)
{
(QDir::addSearchPath(prefix, path));
}
QString PythonQtWrapper_QDir::canonicalPath(QDir* theWrappedObject) const
{
return ( theWrappedObject->canonicalPath());
}
bool PythonQtWrapper_QDir::cd(QDir* theWrappedObject, const QString& dirName)
{
return ( theWrappedObject->cd(dirName));
}
bool PythonQtWrapper_QDir::cdUp(QDir* theWrappedObject)
{
return ( theWrappedObject->cdUp());
}
QString PythonQtWrapper_QDir::static_QDir_cleanPath(const QString& path)
{
return (QDir::cleanPath(path));
}
QString PythonQtWrapper_QDir::static_QDir_convertSeparators(const QString& pathName)
{
return (QDir::convertSeparators(pathName));
}
uint PythonQtWrapper_QDir::count(QDir* theWrappedObject) const
{
return ( theWrappedObject->count());
}
QDir PythonQtWrapper_QDir::static_QDir_current()
{
return (QDir::current());
}
QString PythonQtWrapper_QDir::static_QDir_currentPath()
{
return (QDir::currentPath());
}
QString PythonQtWrapper_QDir::dirName(QDir* theWrappedObject) const
{
return ( theWrappedObject->dirName());
}
QList<QFileInfo > PythonQtWrapper_QDir::static_QDir_drives()
{
return (QDir::drives());
}
QList<QFileInfo > PythonQtWrapper_QDir::entryInfoList(QDir* theWrappedObject, QDir::Filters filters, QDir::SortFlags sort) const
{
return ( theWrappedObject->entryInfoList(filters, sort));
}
QList<QFileInfo > PythonQtWrapper_QDir::entryInfoList(QDir* theWrappedObject, const QStringList& nameFilters, QDir::Filters filters, QDir::SortFlags sort) const
{
return ( theWrappedObject->entryInfoList(nameFilters, filters, sort));
}
QStringList PythonQtWrapper_QDir::entryList(QDir* theWrappedObject, QDir::Filters filters, QDir::SortFlags sort) const
{
return ( theWrappedObject->entryList(filters, sort));
}
QStringList PythonQtWrapper_QDir::entryList(QDir* theWrappedObject, const QStringList& nameFilters, QDir::Filters filters, QDir::SortFlags sort) const
{
return ( theWrappedObject->entryList(nameFilters, filters, sort));
}
bool PythonQtWrapper_QDir::exists(QDir* theWrappedObject) const
{
return ( theWrappedObject->exists());
}
bool PythonQtWrapper_QDir::exists(QDir* theWrappedObject, const QString& name) const
{
return ( theWrappedObject->exists(name));
}
QString PythonQtWrapper_QDir::filePath(QDir* theWrappedObject, const QString& fileName) const
{
return ( theWrappedObject->filePath(fileName));
}
QDir::Filters PythonQtWrapper_QDir::filter(QDir* theWrappedObject) const
{
return ( theWrappedObject->filter());
}
QString PythonQtWrapper_QDir::static_QDir_fromNativeSeparators(const QString& pathName)
{
return (QDir::fromNativeSeparators(pathName));
}
QDir PythonQtWrapper_QDir::static_QDir_home()
{
return (QDir::home());
}
QString PythonQtWrapper_QDir::static_QDir_homePath()
{
return (QDir::homePath());
}
bool PythonQtWrapper_QDir::isAbsolute(QDir* theWrappedObject) const
{
return ( theWrappedObject->isAbsolute());
}
bool PythonQtWrapper_QDir::static_QDir_isAbsolutePath(const QString& path)
{
return (QDir::isAbsolutePath(path));
}
bool PythonQtWrapper_QDir::isReadable(QDir* theWrappedObject) const
{
return ( theWrappedObject->isReadable());
}
bool PythonQtWrapper_QDir::isRelative(QDir* theWrappedObject) const
{
return ( theWrappedObject->isRelative());
}
bool PythonQtWrapper_QDir::static_QDir_isRelativePath(const QString& path)
{
return (QDir::isRelativePath(path));
}
bool PythonQtWrapper_QDir::isRoot(QDir* theWrappedObject) const
{
return ( theWrappedObject->isRoot());
}
bool PythonQtWrapper_QDir::makeAbsolute(QDir* theWrappedObject)
{
return ( theWrappedObject->makeAbsolute());
}
bool PythonQtWrapper_QDir::static_QDir_match(const QString& filter, const QString& fileName)
{
return (QDir::match(filter, fileName));
}
bool PythonQtWrapper_QDir::static_QDir_match(const QStringList& filters, const QString& fileName)
{
return (QDir::match(filters, fileName));
}
bool PythonQtWrapper_QDir::mkdir(QDir* theWrappedObject, const QString& dirName) const
{
return ( theWrappedObject->mkdir(dirName));
}
bool PythonQtWrapper_QDir::mkpath(QDir* theWrappedObject, const QString& dirPath) const
{
return ( theWrappedObject->mkpath(dirPath));
}
QStringList PythonQtWrapper_QDir::nameFilters(QDir* theWrappedObject) const
{
return ( theWrappedObject->nameFilters());
}
QStringList PythonQtWrapper_QDir::static_QDir_nameFiltersFromString(const QString& nameFilter)
{
return (QDir::nameFiltersFromString(nameFilter));
}
bool PythonQtWrapper_QDir::__ne__(QDir* theWrappedObject, const QDir& dir) const
{
return ( (*theWrappedObject)!= dir);
}
bool PythonQtWrapper_QDir::__eq__(QDir* theWrappedObject, const QDir& dir) const
{
return ( (*theWrappedObject)== dir);
}
QString PythonQtWrapper_QDir::operator_subscript(QDir* theWrappedObject, int arg__1) const
{
return ( (*theWrappedObject)[arg__1]);
}
QString PythonQtWrapper_QDir::path(QDir* theWrappedObject) const
{
return ( theWrappedObject->path());
}
void PythonQtWrapper_QDir::refresh(QDir* theWrappedObject) const
{
( theWrappedObject->refresh());
}
QString PythonQtWrapper_QDir::relativeFilePath(QDir* theWrappedObject, const QString& fileName) const
{
return ( theWrappedObject->relativeFilePath(fileName));
}
bool PythonQtWrapper_QDir::remove(QDir* theWrappedObject, const QString& fileName)
{
return ( theWrappedObject->remove(fileName));
}
bool PythonQtWrapper_QDir::rename(QDir* theWrappedObject, const QString& oldName, const QString& newName)
{
return ( theWrappedObject->rename(oldName, newName));
}
bool PythonQtWrapper_QDir::rmdir(QDir* theWrappedObject, const QString& dirName) const
{
return ( theWrappedObject->rmdir(dirName));
}
bool PythonQtWrapper_QDir::rmpath(QDir* theWrappedObject, const QString& dirPath) const
{
return ( theWrappedObject->rmpath(dirPath));
}
QDir PythonQtWrapper_QDir::static_QDir_root()
{
return (QDir::root());
}
QString PythonQtWrapper_QDir::static_QDir_rootPath()
{
return (QDir::rootPath());
}
QStringList PythonQtWrapper_QDir::static_QDir_searchPaths(const QString& prefix)
{
return (QDir::searchPaths(prefix));
}
QChar PythonQtWrapper_QDir::static_QDir_separator()
{
return (QDir::separator());
}
bool PythonQtWrapper_QDir::static_QDir_setCurrent(const QString& path)
{
return (QDir::setCurrent(path));
}
void PythonQtWrapper_QDir::setFilter(QDir* theWrappedObject, QDir::Filters filter)
{
( theWrappedObject->setFilter(filter));
}
void PythonQtWrapper_QDir::setNameFilters(QDir* theWrappedObject, const QStringList& nameFilters)
{
( theWrappedObject->setNameFilters(nameFilters));
}
void PythonQtWrapper_QDir::setPath(QDir* theWrappedObject, const QString& path)
{
( theWrappedObject->setPath(path));
}
void PythonQtWrapper_QDir::static_QDir_setSearchPaths(const QString& prefix, const QStringList& searchPaths)
{
(QDir::setSearchPaths(prefix, searchPaths));
}
void PythonQtWrapper_QDir::setSorting(QDir* theWrappedObject, QDir::SortFlags sort)
{
( theWrappedObject->setSorting(sort));
}
QDir::SortFlags PythonQtWrapper_QDir::sorting(QDir* theWrappedObject) const
{
return ( theWrappedObject->sorting());
}
QDir PythonQtWrapper_QDir::static_QDir_temp()
{
return (QDir::temp());
}
QString PythonQtWrapper_QDir::static_QDir_tempPath()
{
return (QDir::tempPath());
}
QString PythonQtWrapper_QDir::static_QDir_toNativeSeparators(const QString& pathName)
{
return (QDir::toNativeSeparators(pathName));
}
QString PythonQtWrapper_QDir::py_toString(QDir* obj) {
QString result;
QDebug d(&result);
d << *obj;
return result;
}
PythonQtShell_QDirIterator::~PythonQtShell_QDirIterator() {
PythonQtPrivate* priv = PythonQt::priv();
if (priv) { priv->shellClassDeleted(this); }
}
QDirIterator* PythonQtWrapper_QDirIterator::new_QDirIterator(const QDir& dir, QDirIterator::IteratorFlags flags)
{
return new PythonQtShell_QDirIterator(dir, flags); }
QDirIterator* PythonQtWrapper_QDirIterator::new_QDirIterator(const QString& path, QDir::Filters filter, QDirIterator::IteratorFlags flags)
{
return new PythonQtShell_QDirIterator(path, filter, flags); }
QDirIterator* PythonQtWrapper_QDirIterator::new_QDirIterator(const QString& path, QDirIterator::IteratorFlags flags)
{
return new PythonQtShell_QDirIterator(path, flags); }
QDirIterator* PythonQtWrapper_QDirIterator::new_QDirIterator(const QString& path, const QStringList& nameFilters, QDir::Filters filters, QDirIterator::IteratorFlags flags)
{
return new PythonQtShell_QDirIterator(path, nameFilters, filters, flags); }
QFileInfo PythonQtWrapper_QDirIterator::fileInfo(QDirIterator* theWrappedObject) const
{
return ( theWrappedObject->fileInfo());
}
QString PythonQtWrapper_QDirIterator::fileName(QDirIterator* theWrappedObject) const
{
return ( theWrappedObject->fileName());
}
QString PythonQtWrapper_QDirIterator::filePath(QDirIterator* theWrappedObject) const
{
return ( theWrappedObject->filePath());
}
bool PythonQtWrapper_QDirIterator::hasNext(QDirIterator* theWrappedObject) const
{
return ( theWrappedObject->hasNext());
}
QString PythonQtWrapper_QDirIterator::next(QDirIterator* theWrappedObject)
{
return ( theWrappedObject->next());
}
QString PythonQtWrapper_QDirIterator::path(QDirIterator* theWrappedObject) const
{
return ( theWrappedObject->path());
}
QDynamicPropertyChangeEvent* PythonQtWrapper_QDynamicPropertyChangeEvent::new_QDynamicPropertyChangeEvent(const QByteArray& name)
{
return new QDynamicPropertyChangeEvent(name); }
QByteArray PythonQtWrapper_QDynamicPropertyChangeEvent::propertyName(QDynamicPropertyChangeEvent* theWrappedObject) const
{
return ( theWrappedObject->propertyName());
}
QEasingCurve* PythonQtWrapper_QEasingCurve::new_QEasingCurve(QEasingCurve::Type type)
{
return new QEasingCurve(type); }
QEasingCurve* PythonQtWrapper_QEasingCurve::new_QEasingCurve(const QEasingCurve& other)
{
return new QEasingCurve(other); }
qreal PythonQtWrapper_QEasingCurve::amplitude(QEasingCurve* theWrappedObject) const
{
return ( theWrappedObject->amplitude());
}
bool PythonQtWrapper_QEasingCurve::__ne__(QEasingCurve* theWrappedObject, const QEasingCurve& other) const
{
return ( (*theWrappedObject)!= other);
}
void PythonQtWrapper_QEasingCurve::writeTo(QEasingCurve* theWrappedObject, QDataStream& arg__1)
{
arg__1 << (*theWrappedObject);
}
QEasingCurve* PythonQtWrapper_QEasingCurve::operator_assign(QEasingCurve* theWrappedObject, const QEasingCurve& other)
{
return &( (*theWrappedObject)= other);
}
bool PythonQtWrapper_QEasingCurve::__eq__(QEasingCurve* theWrappedObject, const QEasingCurve& other) const
{
return ( (*theWrappedObject)== other);
}
void PythonQtWrapper_QEasingCurve::readFrom(QEasingCurve* theWrappedObject, QDataStream& arg__1)
{
arg__1 >> (*theWrappedObject);
}
qreal PythonQtWrapper_QEasingCurve::overshoot(QEasingCurve* theWrappedObject) const
{
return ( theWrappedObject->overshoot());
}
qreal PythonQtWrapper_QEasingCurve::period(QEasingCurve* theWrappedObject) const
{
return ( theWrappedObject->period());
}
void PythonQtWrapper_QEasingCurve::setAmplitude(QEasingCurve* theWrappedObject, qreal amplitude)
{
( theWrappedObject->setAmplitude(amplitude));
}
void PythonQtWrapper_QEasingCurve::setOvershoot(QEasingCurve* theWrappedObject, qreal overshoot)
{
( theWrappedObject->setOvershoot(overshoot));
}
void PythonQtWrapper_QEasingCurve::setPeriod(QEasingCurve* theWrappedObject, qreal period)
{
( theWrappedObject->setPeriod(period));
}
void PythonQtWrapper_QEasingCurve::setType(QEasingCurve* theWrappedObject, QEasingCurve::Type type)
{
( theWrappedObject->setType(type));
}
QEasingCurve::Type PythonQtWrapper_QEasingCurve::type(QEasingCurve* theWrappedObject) const
{
return ( theWrappedObject->type());
}
qreal PythonQtWrapper_QEasingCurve::valueForProgress(QEasingCurve* theWrappedObject, qreal progress) const
{
return ( theWrappedObject->valueForProgress(progress));
}
QString PythonQtWrapper_QEasingCurve::py_toString(QEasingCurve* obj) {
QString result;
QDebug d(&result);
d << *obj;
return result;
}
PythonQtShell_QElapsedTimer::~PythonQtShell_QElapsedTimer() {
PythonQtPrivate* priv = PythonQt::priv();
if (priv) { priv->shellClassDeleted(this); }
}
QElapsedTimer* PythonQtWrapper_QElapsedTimer::new_QElapsedTimer()
{
return new PythonQtShell_QElapsedTimer(); }
QElapsedTimer::ClockType PythonQtWrapper_QElapsedTimer::static_QElapsedTimer_clockType()
{
return (QElapsedTimer::clockType());
}
qint64 PythonQtWrapper_QElapsedTimer::elapsed(QElapsedTimer* theWrappedObject) const
{
return ( theWrappedObject->elapsed());
}
bool PythonQtWrapper_QElapsedTimer::hasExpired(QElapsedTimer* theWrappedObject, qint64 timeout) const
{
return ( theWrappedObject->hasExpired(timeout));
}
void PythonQtWrapper_QElapsedTimer::invalidate(QElapsedTimer* theWrappedObject)
{
( theWrappedObject->invalidate());
}
bool PythonQtWrapper_QElapsedTimer::static_QElapsedTimer_isMonotonic()
{
return (QElapsedTimer::isMonotonic());
}
bool PythonQtWrapper_QElapsedTimer::isValid(QElapsedTimer* theWrappedObject) const
{
return ( theWrappedObject->isValid());
}
qint64 PythonQtWrapper_QElapsedTimer::msecsSinceReference(QElapsedTimer* theWrappedObject) const
{
return ( theWrappedObject->msecsSinceReference());
}
qint64 PythonQtWrapper_QElapsedTimer::msecsTo(QElapsedTimer* theWrappedObject, const QElapsedTimer& other) const
{
return ( theWrappedObject->msecsTo(other));
}
qint64 PythonQtWrapper_QElapsedTimer::nsecsElapsed(QElapsedTimer* theWrappedObject) const
{
return ( theWrappedObject->nsecsElapsed());
}
bool PythonQtWrapper_QElapsedTimer::__ne__(QElapsedTimer* theWrappedObject, const QElapsedTimer& other) const
{
return ( (*theWrappedObject)!= other);
}
bool PythonQtWrapper_QElapsedTimer::__eq__(QElapsedTimer* theWrappedObject, const QElapsedTimer& other) const
{
return ( (*theWrappedObject)== other);
}
qint64 PythonQtWrapper_QElapsedTimer::restart(QElapsedTimer* theWrappedObject)
{
return ( theWrappedObject->restart());
}
qint64 PythonQtWrapper_QElapsedTimer::secsTo(QElapsedTimer* theWrappedObject, const QElapsedTimer& other) const
{
return ( theWrappedObject->secsTo(other));
}
void PythonQtWrapper_QElapsedTimer::start(QElapsedTimer* theWrappedObject)
{
( theWrappedObject->start());
}
PythonQtShell_QEvent::~PythonQtShell_QEvent() {
PythonQtPrivate* priv = PythonQt::priv();
if (priv) { priv->shellClassDeleted(this); }
}
QEvent* PythonQtWrapper_QEvent::new_QEvent(QEvent::Type type)
{
return new PythonQtShell_QEvent(type); }
void PythonQtWrapper_QEvent::accept(QEvent* theWrappedObject)
{
( theWrappedObject->accept());
}
void PythonQtWrapper_QEvent::ignore(QEvent* theWrappedObject)
{
( theWrappedObject->ignore());
}
bool PythonQtWrapper_QEvent::isAccepted(QEvent* theWrappedObject) const
{
return ( theWrappedObject->isAccepted());
}
int PythonQtWrapper_QEvent::static_QEvent_registerEventType(int hint)
{
return (QEvent::registerEventType(hint));
}
void PythonQtWrapper_QEvent::setAccepted(QEvent* theWrappedObject, bool accepted)
{
( theWrappedObject->setAccepted(accepted));
}
bool PythonQtWrapper_QEvent::spontaneous(QEvent* theWrappedObject) const
{
return ( theWrappedObject->spontaneous());
}
QEvent::Type PythonQtWrapper_QEvent::type(QEvent* theWrappedObject) const
{
return ( theWrappedObject->type());
}
QString PythonQtWrapper_QEvent::py_toString(QEvent* obj) {
QString result;
QDebug d(&result);
d << obj;
return result;
}
PythonQtShell_QEventLoop::~PythonQtShell_QEventLoop() {
PythonQtPrivate* priv = PythonQt::priv();
if (priv) { priv->shellClassDeleted(this); }
}
void PythonQtShell_QEventLoop::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;
}
}
QEventLoop::childEvent(arg__1);
}
void PythonQtShell_QEventLoop::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;
}
}
QEventLoop::customEvent(arg__1);
}
bool PythonQtShell_QEventLoop::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 QEventLoop::event(arg__1);
}
bool PythonQtShell_QEventLoop::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 QEventLoop::eventFilter(arg__1, arg__2);
}
void PythonQtShell_QEventLoop::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;
}
}
QEventLoop::timerEvent(arg__1);
}
QEventLoop* PythonQtWrapper_QEventLoop::new_QEventLoop(QObject* parent)
{
return new PythonQtShell_QEventLoop(parent); }
int PythonQtWrapper_QEventLoop::exec(QEventLoop* theWrappedObject, QEventLoop::ProcessEventsFlags flags)
{
return ( theWrappedObject->exec(flags));
}
void PythonQtWrapper_QEventLoop::exit(QEventLoop* theWrappedObject, int returnCode)
{
( theWrappedObject->exit(returnCode));
}
bool PythonQtWrapper_QEventLoop::isRunning(QEventLoop* theWrappedObject) const
{
return ( theWrappedObject->isRunning());
}
bool PythonQtWrapper_QEventLoop::processEvents(QEventLoop* theWrappedObject, QEventLoop::ProcessEventsFlags flags)
{
return ( theWrappedObject->processEvents(flags));
}
void PythonQtWrapper_QEventLoop::processEvents(QEventLoop* theWrappedObject, QEventLoop::ProcessEventsFlags flags, int maximumTime)
{
( theWrappedObject->processEvents(flags, maximumTime));
}
void PythonQtWrapper_QEventLoop::wakeUp(QEventLoop* theWrappedObject)
{
( theWrappedObject->wakeUp());
}
PythonQtShell_QEventTransition::~PythonQtShell_QEventTransition() {
PythonQtPrivate* priv = PythonQt::priv();
if (priv) { priv->shellClassDeleted(this); }
}
void PythonQtShell_QEventTransition::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;
}
}
QEventTransition::childEvent(arg__1);
}
void PythonQtShell_QEventTransition::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;
}
}
QEventTransition::customEvent(arg__1);
}
bool PythonQtShell_QEventTransition::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 QEventTransition::event(e);
}
bool PythonQtShell_QEventTransition::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 QEventTransition::eventFilter(arg__1, arg__2);
}
bool PythonQtShell_QEventTransition::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 QEventTransition::eventTest(event);
}
void PythonQtShell_QEventTransition::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;
}
}
QEventTransition::onTransition(event);
}
void PythonQtShell_QEventTransition::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;
}
}
QEventTransition::timerEvent(arg__1);
}
QEventTransition* PythonQtWrapper_QEventTransition::new_QEventTransition(QObject* object, QEvent::Type type, QState* sourceState)
{
return new PythonQtShell_QEventTransition(object, type, sourceState); }
QEventTransition* PythonQtWrapper_QEventTransition::new_QEventTransition(QState* sourceState)
{
return new PythonQtShell_QEventTransition(sourceState); }
bool PythonQtWrapper_QEventTransition::event(QEventTransition* theWrappedObject, QEvent* e)
{
return ( ((PythonQtPublicPromoter_QEventTransition*)theWrappedObject)->promoted_event(e));
}
QObject* PythonQtWrapper_QEventTransition::eventSource(QEventTransition* theWrappedObject) const
{
return ( theWrappedObject->eventSource());
}
bool PythonQtWrapper_QEventTransition::eventTest(QEventTransition* theWrappedObject, QEvent* event)
{
return ( ((PythonQtPublicPromoter_QEventTransition*)theWrappedObject)->promoted_eventTest(event));
}
QEvent::Type PythonQtWrapper_QEventTransition::eventType(QEventTransition* theWrappedObject) const
{
return ( theWrappedObject->eventType());
}
void PythonQtWrapper_QEventTransition::onTransition(QEventTransition* theWrappedObject, QEvent* event)
{
( ((PythonQtPublicPromoter_QEventTransition*)theWrappedObject)->promoted_onTransition(event));
}
void PythonQtWrapper_QEventTransition::setEventSource(QEventTransition* theWrappedObject, QObject* object)
{
( theWrappedObject->setEventSource(object));
}
void PythonQtWrapper_QEventTransition::setEventType(QEventTransition* theWrappedObject, QEvent::Type type)
{
( theWrappedObject->setEventType(type));
}
PythonQtShell_QFactoryInterface::~PythonQtShell_QFactoryInterface() {
PythonQtPrivate* priv = PythonQt::priv();
if (priv) { priv->shellClassDeleted(this); }
}
QStringList PythonQtShell_QFactoryInterface::keys() const
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "keys");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"QStringList"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
QStringList 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("keys", methodInfo, result);
} else {
returnValue = *((QStringList*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QStringList();
}
QFactoryInterface* PythonQtWrapper_QFactoryInterface::new_QFactoryInterface()
{
return new PythonQtShell_QFactoryInterface(); }
PythonQtShell_QFile::~PythonQtShell_QFile() {
PythonQtPrivate* priv = PythonQt::priv();
if (priv) { priv->shellClassDeleted(this); }
}
bool PythonQtShell_QFile::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 QFile::atEnd();
}
qint64 PythonQtShell_QFile::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 QFile::bytesAvailable();
}
qint64 PythonQtShell_QFile::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 QFile::bytesToWrite();
}
bool PythonQtShell_QFile::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 QFile::canReadLine();
}
void PythonQtShell_QFile::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;
}
}
QFile::childEvent(arg__1);
}
void PythonQtShell_QFile::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;
}
}
QFile::close();
}
void PythonQtShell_QFile::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;
}
}
QFile::customEvent(arg__1);
}
bool PythonQtShell_QFile::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 QFile::event(arg__1);
}
bool PythonQtShell_QFile::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 QFile::eventFilter(arg__1, arg__2);
}
QAbstractFileEngine* PythonQtShell_QFile::fileEngine() const
{
if (_wrapper) {
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "fileEngine");
PyErr_Clear();
if (obj && !PythonQtSlotFunction_Check(obj)) {
static const char* argumentList[] ={"QAbstractFileEngine*"};
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
QAbstractFileEngine* 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("fileEngine", methodInfo, result);
} else {
returnValue = *((QAbstractFileEngine**)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QFile::fileEngine();
}
bool PythonQtShell_QFile::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 QFile::isSequential();
}
bool PythonQtShell_QFile::open(QIODevice::OpenMode flags)
{
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*)&flags};
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 QFile::open(flags);
}
qint64 PythonQtShell_QFile::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 QFile::pos();
}
qint64 PythonQtShell_QFile::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 QFile::readData(data, maxlen);
}
qint64 PythonQtShell_QFile::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 QFile::readLineData(data, maxlen);
}
bool PythonQtShell_QFile::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 QFile::reset();
}
bool PythonQtShell_QFile::seek(qint64 offset)
{
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*)&offset};
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
if (result) {
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
if (args[0]!=&returnValue) {
if (args[0]==NULL) {
PythonQt::priv()->handleVirtualOverloadReturnError("seek", methodInfo, result);
} else {
returnValue = *((bool*)args[0]);
}
}
}
if (result) { Py_DECREF(result); }
Py_DECREF(obj);
return returnValue;
}
}
return QFile::seek(offset);
}
qint64 PythonQtShell_QFile::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 QFile::size();
}
void PythonQtShell_QFile::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;
}
}
QFile::timerEvent(arg__1);
}
bool PythonQtShell_QFile::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 QFile::waitForBytesWritten(msecs);
}
bool PythonQtShell_QFile::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 QFile::waitForReadyRead(msecs);
}
qint64 PythonQtShell_QFile::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 QFile::writeData(data, len);
}
QFile* PythonQtWrapper_QFile::new_QFile()
{
return new PythonQtShell_QFile(); }
QFile* PythonQtWrapper_QFile::new_QFile(QObject* parent)
{
return new PythonQtShell_QFile(parent); }
QFile* PythonQtWrapper_QFile::new_QFile(const QString& name)
{
return new PythonQtShell_QFile(name); }
QFile* PythonQtWrapper_QFile::new_QFile(const QString& name, QObject* parent)
{
return new PythonQtShell_QFile(name, parent); }
bool PythonQtWrapper_QFile::atEnd(QFile* theWrappedObject) const
{
return ( ((PythonQtPublicPromoter_QFile*)theWrappedObject)->promoted_atEnd());
}
void PythonQtWrapper_QFile::close(QFile* theWrappedObject)
{
( ((PythonQtPublicPromoter_QFile*)theWrappedObject)->promoted_close());
}
bool PythonQtWrapper_QFile::static_QFile_copy(const QString& fileName, const QString& newName)
{
return (QFile::copy(fileName, newName));
}
bool PythonQtWrapper_QFile::copy(QFile* theWrappedObject, const QString& newName)
{
return ( theWrappedObject->copy(newName));
}
QString PythonQtWrapper_QFile::static_QFile_decodeName(const QByteArray& localFileName)
{
return (QFile::decodeName(localFileName));
}
QByteArray PythonQtWrapper_QFile::static_QFile_encodeName(const QString& fileName)
{
return (QFile::encodeName(fileName));
}
QFile::FileError PythonQtWrapper_QFile::error(QFile* theWrappedObject) const
{
return ( theWrappedObject->error());
}
bool PythonQtWrapper_QFile::exists(QFile* theWrappedObject) const
{
return ( theWrappedObject->exists());
}
bool PythonQtWrapper_QFile::static_QFile_exists(const QString& fileName)
{
return (QFile::exists(fileName));
}
QAbstractFileEngine* PythonQtWrapper_QFile::fileEngine(QFile* theWrappedObject) const
{
return ( ((PythonQtPublicPromoter_QFile*)theWrappedObject)->promoted_fileEngine());
}
QString PythonQtWrapper_QFile::fileName(QFile* theWrappedObject) const
{
return ( theWrappedObject->fileName());
}
bool PythonQtWrapper_QFile::flush(QFile* theWrappedObject)
{
return ( theWrappedObject->flush());
}
int PythonQtWrapper_QFile::handle(QFile* theWrappedObject) const
{
return ( theWrappedObject->handle());
}
bool PythonQtWrapper_QFile::isSequential(QFile* theWrappedObject) const
{
return ( ((PythonQtPublicPromoter_QFile*)theWrappedObject)->promoted_isSequential());
}
bool PythonQtWrapper_QFile::link(QFile* theWrappedObject, const QString& newName)
{
return ( theWrappedObject->link(newName));
}
bool PythonQtWrapper_QFile::static_QFile_link(const QString& oldname, const QString& newName)
{
return (QFile::link(oldname, newName));
}
bool PythonQtWrapper_QFile::open(QFile* theWrappedObject, QIODevice::OpenMode flags)
{
return ( ((PythonQtPublicPromoter_QFile*)theWrappedObject)->promoted_open(flags));
}
bool PythonQtWrapper_QFile::open(QFile* theWrappedObject, int fd, QIODevice::OpenMode ioFlags, QFile::FileHandleFlags handleFlags)
{
return ( theWrappedObject->open(fd, ioFlags, handleFlags));
}
QFile::Permissions PythonQtWrapper_QFile::permissions(QFile* theWrappedObject) const
{
return ( theWrappedObject->permissions());
}
QFile::Permissions PythonQtWrapper_QFile::static_QFile_permissions(const QString& filename)
{
return (QFile::permissions(filename));
}
qint64 PythonQtWrapper_QFile::pos(QFile* theWrappedObject) const
{
return ( ((PythonQtPublicPromoter_QFile*)theWrappedObject)->promoted_pos());
}
qint64 PythonQtWrapper_QFile::readData(QFile* theWrappedObject, char* data, qint64 maxlen)
{
return ( ((PythonQtPublicPromoter_QFile*)theWrappedObject)->promoted_readData(data, maxlen));
}
qint64 PythonQtWrapper_QFile::readLineData(QFile* theWrappedObject, char* data, qint64 maxlen)
{
return ( ((PythonQtPublicPromoter_QFile*)theWrappedObject)->promoted_readLineData(data, maxlen));
}
bool PythonQtWrapper_QFile::remove(QFile* theWrappedObject)
{
return ( theWrappedObject->remove());
}
bool PythonQtWrapper_QFile::static_QFile_remove(const QString& fileName)
{
return (QFile::remove(fileName));
}
bool PythonQtWrapper_QFile::rename(QFile* theWrappedObject, const QString& newName)
{
return ( theWrappedObject->rename(newName));
}
bool PythonQtWrapper_QFile::static_QFile_rename(const QString& oldName, const QString& newName)
{
return (QFile::rename(oldName, newName));
}
bool PythonQtWrapper_QFile::static_QFile_resize(const QString& filename, qint64 sz)
{
return (QFile::resize(filename, sz));
}
bool PythonQtWrapper_QFile::resize(QFile* theWrappedObject, qint64 sz)
{
return ( theWrappedObject->resize(sz));
}
bool PythonQtWrapper_QFile::seek(QFile* theWrappedObject, qint64 offset)
{
return ( ((PythonQtPublicPromoter_QFile*)theWrappedObject)->promoted_seek(offset));
}
void PythonQtWrapper_QFile::setFileName(QFile* theWrappedObject, const QString& name)
{
( theWrappedObject->setFileName(name));
}
bool PythonQtWrapper_QFile::setPermissions(QFile* theWrappedObject, QFile::Permissions permissionSpec)
{
return ( theWrappedObject->setPermissions(permissionSpec));
}
bool PythonQtWrapper_QFile::static_QFile_setPermissions(const QString& filename, QFile::Permissions permissionSpec)
{
return (QFile::setPermissions(filename, permissionSpec));
}
qint64 PythonQtWrapper_QFile::size(QFile* theWrappedObject) const
{
return ( ((PythonQtPublicPromoter_QFile*)theWrappedObject)->promoted_size());
}
QString PythonQtWrapper_QFile::symLinkTarget(QFile* theWrappedObject) const
{
return ( theWrappedObject->symLinkTarget());
}
QString PythonQtWrapper_QFile::static_QFile_symLinkTarget(const QString& fileName)
{
return (QFile::symLinkTarget(fileName));
}
void PythonQtWrapper_QFile::unsetError(QFile* theWrappedObject)
{
( theWrappedObject->unsetError());
}
qint64 PythonQtWrapper_QFile::writeData(QFile* theWrappedObject, const char* data, qint64 len)
{
return ( ((PythonQtPublicPromoter_QFile*)theWrappedObject)->promoted_writeData(data, len));
}
QFileInfo* PythonQtWrapper_QFileInfo::new_QFileInfo()
{
return new QFileInfo(); }
QFileInfo* PythonQtWrapper_QFileInfo::new_QFileInfo(const QDir& dir, const QString& file)
{
return new QFileInfo(dir, file); }
QFileInfo* PythonQtWrapper_QFileInfo::new_QFileInfo(const QFile& file)
{
return new QFileInfo(file); }
QFileInfo* PythonQtWrapper_QFileInfo::new_QFileInfo(const QFileInfo& fileinfo)
{
return new QFileInfo(fileinfo); }
QFileInfo* PythonQtWrapper_QFileInfo::new_QFileInfo(const QString& file)
{
return new QFileInfo(file); }
QDir PythonQtWrapper_QFileInfo::absoluteDir(QFileInfo* theWrappedObject) const
{
return ( theWrappedObject->absoluteDir());
}
QString PythonQtWrapper_QFileInfo::absoluteFilePath(QFileInfo* theWrappedObject) const
{
return ( theWrappedObject->absoluteFilePath());
}
QString PythonQtWrapper_QFileInfo::absolutePath(QFileInfo* theWrappedObject) const
{
return ( theWrappedObject->absolutePath());
}
QString PythonQtWrapper_QFileInfo::baseName(QFileInfo* theWrappedObject) const
{
return ( theWrappedObject->baseName());
}
QString PythonQtWrapper_QFileInfo::bundleName(QFileInfo* theWrappedObject) const
{
return ( theWrappedObject->bundleName());
}
bool PythonQtWrapper_QFileInfo::caching(QFileInfo* theWrappedObject) const
{
return ( theWrappedObject->caching());
}
QString PythonQtWrapper_QFileInfo::canonicalFilePath(QFileInfo* theWrappedObject) const
{
return ( theWrappedObject->canonicalFilePath());
}
QString PythonQtWrapper_QFileInfo::canonicalPath(QFileInfo* theWrappedObject) const
{
return ( theWrappedObject->canonicalPath());
}
QString PythonQtWrapper_QFileInfo::completeBaseName(QFileInfo* theWrappedObject) const
{
return ( theWrappedObject->completeBaseName());
}
QString PythonQtWrapper_QFileInfo::completeSuffix(QFileInfo* theWrappedObject) const
{
return ( theWrappedObject->completeSuffix());
}
QDateTime PythonQtWrapper_QFileInfo::created(QFileInfo* theWrappedObject) const
{
return ( theWrappedObject->created());
}
QDir PythonQtWrapper_QFileInfo::dir(QFileInfo* theWrappedObject) const
{
return ( theWrappedObject->dir());
}
bool PythonQtWrapper_QFileInfo::exists(QFileInfo* theWrappedObject) const
{
return ( theWrappedObject->exists());
}
QString PythonQtWrapper_QFileInfo::fileName(QFileInfo* theWrappedObject) const
{
return ( theWrappedObject->fileName());
}
QString PythonQtWrapper_QFileInfo::filePath(QFileInfo* theWrappedObject) const
{
return ( theWrappedObject->filePath());
}
QString PythonQtWrapper_QFileInfo::group(QFileInfo* theWrappedObject) const
{
return ( theWrappedObject->group());
}
uint PythonQtWrapper_QFileInfo::groupId(QFileInfo* theWrappedObject) const
{
return ( theWrappedObject->groupId());
}
bool PythonQtWrapper_QFileInfo::isAbsolute(QFileInfo* theWrappedObject) const
{
return ( theWrappedObject->isAbsolute());
}
bool PythonQtWrapper_QFileInfo::isBundle(QFileInfo* theWrappedObject) const
{
return ( theWrappedObject->isBundle());
}
bool PythonQtWrapper_QFileInfo::isDir(QFileInfo* theWrappedObject) const
{
return ( theWrappedObject->isDir());
}
bool PythonQtWrapper_QFileInfo::isExecutable(QFileInfo* theWrappedObject) const
{
return ( theWrappedObject->isExecutable());
}
bool PythonQtWrapper_QFileInfo::isFile(QFileInfo* theWrappedObject) const
{
return ( theWrappedObject->isFile());
}
bool PythonQtWrapper_QFileInfo::isHidden(QFileInfo* theWrappedObject) const
{
return ( theWrappedObject->isHidden());
}
bool PythonQtWrapper_QFileInfo::isReadable(QFileInfo* theWrappedObject) const
{
return ( theWrappedObject->isReadable());
}
bool PythonQtWrapper_QFileInfo::isRelative(QFileInfo* theWrappedObject) const
{
return ( theWrappedObject->isRelative());
}
bool PythonQtWrapper_QFileInfo::isRoot(QFileInfo* theWrappedObject) const
{
return ( theWrappedObject->isRoot());
}
bool PythonQtWrapper_QFileInfo::isSymLink(QFileInfo* theWrappedObject) const
{
return ( theWrappedObject->isSymLink());
}
bool PythonQtWrapper_QFileInfo::isWritable(QFileInfo* theWrappedObject) const
{
return ( theWrappedObject->isWritable());
}
QDateTime PythonQtWrapper_QFileInfo::lastModified(QFileInfo* theWrappedObject) const
{
return ( theWrappedObject->lastModified());
}
QDateTime PythonQtWrapper_QFileInfo::lastRead(QFileInfo* theWrappedObject) const
{
return ( theWrappedObject->lastRead());
}
bool PythonQtWrapper_QFileInfo::makeAbsolute(QFileInfo* theWrappedObject)
{
return ( theWrappedObject->makeAbsolute());
}
bool PythonQtWrapper_QFileInfo::__ne__(QFileInfo* theWrappedObject, const QFileInfo& fileinfo)
{
return ( (*theWrappedObject)!= fileinfo);
}
bool PythonQtWrapper_QFileInfo::__eq__(QFileInfo* theWrappedObject, const QFileInfo& fileinfo)
{
return ( (*theWrappedObject)== fileinfo);
}
QString PythonQtWrapper_QFileInfo::owner(QFileInfo* theWrappedObject) const
{
return ( theWrappedObject->owner());
}
uint PythonQtWrapper_QFileInfo::ownerId(QFileInfo* theWrappedObject) const
{
return ( theWrappedObject->ownerId());
}
QString PythonQtWrapper_QFileInfo::path(QFileInfo* theWrappedObject) const
{
return ( theWrappedObject->path());
}
bool PythonQtWrapper_QFileInfo::permission(QFileInfo* theWrappedObject, QFile::Permissions permissions) const
{
return ( theWrappedObject->permission(permissions));
}
QFile::Permissions PythonQtWrapper_QFileInfo::permissions(QFileInfo* theWrappedObject) const
{
return ( theWrappedObject->permissions());
}
void PythonQtWrapper_QFileInfo::refresh(QFileInfo* theWrappedObject)
{
( theWrappedObject->refresh());
}
void PythonQtWrapper_QFileInfo::setCaching(QFileInfo* theWrappedObject, bool on)
{
( theWrappedObject->setCaching(on));
}
void PythonQtWrapper_QFileInfo::setFile(QFileInfo* theWrappedObject, const QDir& dir, const QString& file)
{
( theWrappedObject->setFile(dir, file));
}
void PythonQtWrapper_QFileInfo::setFile(QFileInfo* theWrappedObject, const QFile& file)
{
( theWrappedObject->setFile(file));
}
void PythonQtWrapper_QFileInfo::setFile(QFileInfo* theWrappedObject, const QString& file)
{
( theWrappedObject->setFile(file));
}
qint64 PythonQtWrapper_QFileInfo::size(QFileInfo* theWrappedObject) const
{
return ( theWrappedObject->size());
}
QString PythonQtWrapper_QFileInfo::suffix(QFileInfo* theWrappedObject) const
{
return ( theWrappedObject->suffix());
}
QString PythonQtWrapper_QFileInfo::symLinkTarget(QFileInfo* theWrappedObject) const
{
return ( theWrappedObject->symLinkTarget());
}
PythonQtShell_QFileSystemWatcher::~PythonQtShell_QFileSystemWatcher() {
PythonQtPrivate* priv = PythonQt::priv();
if (priv) { priv->shellClassDeleted(this); }
}
void PythonQtShell_QFileSystemWatcher::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;
}
}
QFileSystemWatcher::childEvent(arg__1);
}
void PythonQtShell_QFileSystemWatcher::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;
}
}
QFileSystemWatcher::customEvent(arg__1);
}
bool PythonQtShell_QFileSystemWatcher::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 QFileSystemWatcher::event(arg__1);
}
bool PythonQtShell_QFileSystemWatcher::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 QFileSystemWatcher::eventFilter(arg__1, arg__2);
}
void PythonQtShell_QFileSystemWatcher::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;
}
}
QFileSystemWatcher::timerEvent(arg__1);
}
QFileSystemWatcher* PythonQtWrapper_QFileSystemWatcher::new_QFileSystemWatcher(QObject* parent)
{
return new PythonQtShell_QFileSystemWatcher(parent); }
QFileSystemWatcher* PythonQtWrapper_QFileSystemWatcher::new_QFileSystemWatcher(const QStringList& paths, QObject* parent)
{
return new PythonQtShell_QFileSystemWatcher(paths, parent); }
void PythonQtWrapper_QFileSystemWatcher::addPath(QFileSystemWatcher* theWrappedObject, const QString& file)
{
( theWrappedObject->addPath(file));
}
void PythonQtWrapper_QFileSystemWatcher::addPaths(QFileSystemWatcher* theWrappedObject, const QStringList& files)
{
( theWrappedObject->addPaths(files));
}
QStringList PythonQtWrapper_QFileSystemWatcher::directories(QFileSystemWatcher* theWrappedObject) const
{
return ( theWrappedObject->directories());
}
QStringList PythonQtWrapper_QFileSystemWatcher::files(QFileSystemWatcher* theWrappedObject) const
{
return ( theWrappedObject->files());
}
void PythonQtWrapper_QFileSystemWatcher::removePath(QFileSystemWatcher* theWrappedObject, const QString& file)
{
( theWrappedObject->removePath(file));
}
void PythonQtWrapper_QFileSystemWatcher::removePaths(QFileSystemWatcher* theWrappedObject, const QStringList& files)
{
( theWrappedObject->removePaths(files));
}
PythonQtShell_QFinalState::~PythonQtShell_QFinalState() {
PythonQtPrivate* priv = PythonQt::priv();
if (priv) { priv->shellClassDeleted(this); }
}
void PythonQtShell_QFinalState::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;
}
}
QFinalState::childEvent(arg__1);
}
void PythonQtShell_QFinalState::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;
}
}
QFinalState::customEvent(arg__1);
}
bool PythonQtShell_QFinalState::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 QFinalState::event(e);
}
bool PythonQtShell_QFinalState::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 QFinalState::eventFilter(arg__1, arg__2);
}
void PythonQtShell_QFinalState::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;
}
}
QFinalState::onEntry(event);
}
void PythonQtShell_QFinalState::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;
}
}
QFinalState::onExit(event);
}
void PythonQtShell_QFinalState::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;
}
}
QFinalState::timerEvent(arg__1);
}
QFinalState* PythonQtWrapper_QFinalState::new_QFinalState(QState* parent)
{
return new PythonQtShell_QFinalState(parent); }
bool PythonQtWrapper_QFinalState::event(QFinalState* theWrappedObject, QEvent* e)
{
return ( ((PythonQtPublicPromoter_QFinalState*)theWrappedObject)->promoted_event(e));
}
void PythonQtWrapper_QFinalState::onEntry(QFinalState* theWrappedObject, QEvent* event)
{
( ((PythonQtPublicPromoter_QFinalState*)theWrappedObject)->promoted_onEntry(event));
}
void PythonQtWrapper_QFinalState::onExit(QFinalState* theWrappedObject, QEvent* event)
{
( ((PythonQtPublicPromoter_QFinalState*)theWrappedObject)->promoted_onExit(event));
}
PythonQtShell_QHistoryState::~PythonQtShell_QHistoryState() {
PythonQtPrivate* priv = PythonQt::priv();
if (priv) { priv->shellClassDeleted(this); }
}
void PythonQtShell_QHistoryState::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;
}
}
QHistoryState::childEvent(arg__1);
}
void PythonQtShell_QHistoryState::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;
}
}
QHistoryState::customEvent(arg__1);
}
bool PythonQtShell_QHistoryState::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 QHistoryState::event(e);
}
bool PythonQtShell_QHistoryState::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 QHistoryState::eventFilter(arg__1, arg__2);
}
void PythonQtShell_QHistoryState::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;
}
}
QHistoryState::onEntry(event);
}
void PythonQtShell_QHistoryState::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;
}
}
QHistoryState::onExit(event);
}
void PythonQtShell_QHistoryState::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;
}
}
QHistoryState::timerEvent(arg__1);
}
QHistoryState* PythonQtWrapper_QHistoryState::new_QHistoryState(QHistoryState::HistoryType type, QState* parent)
{
return new PythonQtShell_QHistoryState(type, parent); }
QHistoryState* PythonQtWrapper_QHistoryState::new_QHistoryState(QState* parent)
{
return new PythonQtShell_QHistoryState(parent); }
QAbstractState* PythonQtWrapper_QHistoryState::defaultState(QHistoryState* theWrappedObject) const
{
return ( theWrappedObject->defaultState());
}
bool PythonQtWrapper_QHistoryState::event(QHistoryState* theWrappedObject, QEvent* e)
{
return ( ((PythonQtPublicPromoter_QHistoryState*)theWrappedObject)->promoted_event(e));
}
QHistoryState::HistoryType PythonQtWrapper_QHistoryState::historyType(QHistoryState* theWrappedObject) const
{
return ( theWrappedObject->historyType());
}
void PythonQtWrapper_QHistoryState::onEntry(QHistoryState* theWrappedObject, QEvent* event)
{
( ((PythonQtPublicPromoter_QHistoryState*)theWrappedObject)->promoted_onEntry(event));
}
void PythonQtWrapper_QHistoryState::onExit(QHistoryState* theWrappedObject, QEvent* event)
{
( ((PythonQtPublicPromoter_QHistoryState*)theWrappedObject)->promoted_onExit(event));
}
void PythonQtWrapper_QHistoryState::setDefaultState(QHistoryState* theWrappedObject, QAbstractState* state)
{
( theWrappedObject->setDefaultState(state));
}
void PythonQtWrapper_QHistoryState::setHistoryType(QHistoryState* theWrappedObject, QHistoryState::HistoryType type)
{
( theWrappedObject->setHistoryType(type));
}
PythonQtShell_QIODevice::~PythonQtShell_QIODevice() {
PythonQtPrivate* priv = PythonQt::priv();
if (priv) { priv->shellClassDeleted(this); }
}
bool PythonQtShell_QIODevice::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 QIODevice::atEnd();
}
qint64 PythonQtShell_QIODevice::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 QIODevice::bytesAvailable();
}
qint64 PythonQtShell_QIODevice::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 QIODevice::bytesToWrite();
}
bool PythonQtShell_QIODevice::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 QIODevice::canReadLine();
}
void PythonQtShell_QIODevice::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;
}
}
QIODevice::childEvent(arg__1);
}
void PythonQtShell_QIODevice::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;
}
}
QIODevice::close();
}
void PythonQtShell_QIODevice::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;
}
}
QIODevice::customEvent(arg__1);
}
bool PythonQtShell_QIODevice::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 QIODevice::event(arg__1);
}
bool PythonQtShell_QIODevice::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 QIODevice::eventFilter(arg__1, arg__2);
}
bool PythonQtShell_QIODevice::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 QIODevice::isSequential();
}
bool PythonQtShell_QIODevice::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 QIODevice::open(mode);
}
qint64 PythonQtShell_QIODevice::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 QIODevice::pos();
}
qint64 PythonQtShell_QIODevice::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 qint64();
}
qint64 PythonQtShell_QIODevice::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 QIODevice::readLineData(data, maxlen);
}
bool PythonQtShell_QIODevice::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 QIODevice::reset();
}
bool PythonQtShell_QIODevice::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 QIODevice::seek(pos);
}
qint64 PythonQtShell_QIODevice::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 QIODevice::size();
}
void PythonQtShell_QIODevice::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;
}
}
QIODevice::timerEvent(arg__1);
}
bool PythonQtShell_QIODevice::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 QIODevice::waitForBytesWritten(msecs);
}
bool PythonQtShell_QIODevice::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 QIODevice::waitForReadyRead(msecs);
}
qint64 PythonQtShell_QIODevice::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 qint64();
}
QIODevice* PythonQtWrapper_QIODevice::new_QIODevice()
{
return new PythonQtShell_QIODevice(); }
QIODevice* PythonQtWrapper_QIODevice::new_QIODevice(QObject* parent)
{
return new PythonQtShell_QIODevice(parent); }
bool PythonQtWrapper_QIODevice::atEnd(QIODevice* theWrappedObject) const
{
return ( ((PythonQtPublicPromoter_QIODevice*)theWrappedObject)->promoted_atEnd());
}
qint64 PythonQtWrapper_QIODevice::bytesAvailable(QIODevice* theWrappedObject) const
{
return ( ((PythonQtPublicPromoter_QIODevice*)theWrappedObject)->promoted_bytesAvailable());
}
qint64 PythonQtWrapper_QIODevice::bytesToWrite(QIODevice* theWrappedObject) const
{
return ( ((PythonQtPublicPromoter_QIODevice*)theWrappedObject)->promoted_bytesToWrite());
}
bool PythonQtWrapper_QIODevice::canReadLine(QIODevice* theWrappedObject) const
{
return ( ((PythonQtPublicPromoter_QIODevice*)theWrappedObject)->promoted_canReadLine());
}
void PythonQtWrapper_QIODevice::close(QIODevice* theWrappedObject)
{
( ((PythonQtPublicPromoter_QIODevice*)theWrappedObject)->promoted_close());
}
QString PythonQtWrapper_QIODevice::errorString(QIODevice* theWrappedObject) const
{
return ( theWrappedObject->errorString());
}
bool PythonQtWrapper_QIODevice::getChar(QIODevice* theWrappedObject, char* c)
{
return ( theWrappedObject->getChar(c));
}
bool PythonQtWrapper_QIODevice::isOpen(QIODevice* theWrappedObject) const
{
return ( theWrappedObject->isOpen());
}
bool PythonQtWrapper_QIODevice::isReadable(QIODevice* theWrappedObject) const
{
return ( theWrappedObject->isReadable());
}
bool PythonQtWrapper_QIODevice::isSequential(QIODevice* theWrappedObject) const
{
return ( ((PythonQtPublicPromoter_QIODevice*)theWrappedObject)->promoted_isSequential());
}
bool PythonQtWrapper_QIODevice::isTextModeEnabled(QIODevice* theWrappedObject) const
{
return ( theWrappedObject->isTextModeEnabled());
}
bool PythonQtWrapper_QIODevice::isWritable(QIODevice* theWrappedObject) const
{
return ( theWrappedObject->isWritable());
}
bool PythonQtWrapper_QIODevice::open(QIODevice* theWrappedObject, QIODevice::OpenMode mode)
{
return ( ((PythonQtPublicPromoter_QIODevice*)theWrappedObject)->promoted_open(mode));
}
QIODevice::OpenMode PythonQtWrapper_QIODevice::openMode(QIODevice* theWrappedObject) const
{
return ( theWrappedObject->openMode());
}
QByteArray PythonQtWrapper_QIODevice::peek(QIODevice* theWrappedObject, qint64 maxlen)
{
return ( theWrappedObject->peek(maxlen));
}
qint64 PythonQtWrapper_QIODevice::pos(QIODevice* theWrappedObject) const
{
return ( ((PythonQtPublicPromoter_QIODevice*)theWrappedObject)->promoted_pos());
}
bool PythonQtWrapper_QIODevice::putChar(QIODevice* theWrappedObject, char c)
{
return ( theWrappedObject->putChar(c));
}
QByteArray PythonQtWrapper_QIODevice::read(QIODevice* theWrappedObject, qint64 maxlen)
{
return ( theWrappedObject->read(maxlen));
}
QByteArray PythonQtWrapper_QIODevice::readAll(QIODevice* theWrappedObject)
{
return ( theWrappedObject->readAll());
}
QByteArray PythonQtWrapper_QIODevice::readLine(QIODevice* theWrappedObject, qint64 maxlen)
{
return ( theWrappedObject->readLine(maxlen));
}
qint64 PythonQtWrapper_QIODevice::readLineData(QIODevice* theWrappedObject, char* data, qint64 maxlen)
{
return ( ((PythonQtPublicPromoter_QIODevice*)theWrappedObject)->promoted_readLineData(data, maxlen));
}
bool PythonQtWrapper_QIODevice::reset(QIODevice* theWrappedObject)
{
return ( ((PythonQtPublicPromoter_QIODevice*)theWrappedObject)->promoted_reset());
}
bool PythonQtWrapper_QIODevice::seek(QIODevice* theWrappedObject, qint64 pos)
{
return ( ((PythonQtPublicPromoter_QIODevice*)theWrappedObject)->promoted_seek(pos));
}
void PythonQtWrapper_QIODevice::setTextModeEnabled(QIODevice* theWrappedObject, bool enabled)
{
( theWrappedObject->setTextModeEnabled(enabled));
}
qint64 PythonQtWrapper_QIODevice::size(QIODevice* theWrappedObject) const
{
return ( ((PythonQtPublicPromoter_QIODevice*)theWrappedObject)->promoted_size());
}
void PythonQtWrapper_QIODevice::ungetChar(QIODevice* theWrappedObject, char c)
{
( theWrappedObject->ungetChar(c));
}
bool PythonQtWrapper_QIODevice::waitForBytesWritten(QIODevice* theWrappedObject, int msecs)
{
return ( ((PythonQtPublicPromoter_QIODevice*)theWrappedObject)->promoted_waitForBytesWritten(msecs));
}
bool PythonQtWrapper_QIODevice::waitForReadyRead(QIODevice* theWrappedObject, int msecs)
{
return ( ((PythonQtPublicPromoter_QIODevice*)theWrappedObject)->promoted_waitForReadyRead(msecs));
}
qint64 PythonQtWrapper_QIODevice::write(QIODevice* theWrappedObject, const QByteArray& data)
{
return ( theWrappedObject->write(data));
}
qint64 PythonQtWrapper_QIODevice::write(QIODevice* theWrappedObject, const char* data)
{
return ( theWrappedObject->write(data));
}
PythonQtShell_QLibrary::~PythonQtShell_QLibrary() {
PythonQtPrivate* priv = PythonQt::priv();
if (priv) { priv->shellClassDeleted(this); }
}
void PythonQtShell_QLibrary::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;
}
}
QLibrary::childEvent(arg__1);
}
void PythonQtShell_QLibrary::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;
}
}
QLibrary::customEvent(arg__1);
}
bool PythonQtShell_QLibrary::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 QLibrary::event(arg__1);
}
bool PythonQtShell_QLibrary::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 QLibrary::eventFilter(arg__1, arg__2);
}
void PythonQtShell_QLibrary::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;
}
}
QLibrary::timerEvent(arg__1);
}
QLibrary* PythonQtWrapper_QLibrary::new_QLibrary(QObject* parent)
{
return new PythonQtShell_QLibrary(parent); }
QLibrary* PythonQtWrapper_QLibrary::new_QLibrary(const QString& fileName, QObject* parent)
{
return new PythonQtShell_QLibrary(fileName, parent); }
QLibrary* PythonQtWrapper_QLibrary::new_QLibrary(const QString& fileName, const QString& version, QObject* parent)
{
return new PythonQtShell_QLibrary(fileName, version, parent); }
QLibrary* PythonQtWrapper_QLibrary::new_QLibrary(const QString& fileName, int verNum, QObject* parent)
{
return new PythonQtShell_QLibrary(fileName, verNum, parent); }
QString PythonQtWrapper_QLibrary::errorString(QLibrary* theWrappedObject) const
{
return ( theWrappedObject->errorString());
}
QString PythonQtWrapper_QLibrary::fileName(QLibrary* theWrappedObject) const
{
return ( theWrappedObject->fileName());
}
bool PythonQtWrapper_QLibrary::static_QLibrary_isLibrary(const QString& fileName)
{
return (QLibrary::isLibrary(fileName));
}
bool PythonQtWrapper_QLibrary::isLoaded(QLibrary* theWrappedObject) const
{
return ( theWrappedObject->isLoaded());
}
bool PythonQtWrapper_QLibrary::load(QLibrary* theWrappedObject)
{
return ( theWrappedObject->load());
}
QLibrary::LoadHints PythonQtWrapper_QLibrary::loadHints(QLibrary* theWrappedObject) const
{
return ( theWrappedObject->loadHints());
}
void* PythonQtWrapper_QLibrary::static_QLibrary_resolve(const QString& fileName, const QString& version, const char* symbol)
{
return (QLibrary::resolve(fileName, version, symbol));
}
void* PythonQtWrapper_QLibrary::static_QLibrary_resolve(const QString& fileName, const char* symbol)
{
return (QLibrary::resolve(fileName, symbol));
}
void* PythonQtWrapper_QLibrary::static_QLibrary_resolve(const QString& fileName, int verNum, const char* symbol)
{
return (QLibrary::resolve(fileName, verNum, symbol));
}
void* PythonQtWrapper_QLibrary::resolve(QLibrary* theWrappedObject, const char* symbol)
{
return ( theWrappedObject->resolve(symbol));
}
void PythonQtWrapper_QLibrary::setFileName(QLibrary* theWrappedObject, const QString& fileName)
{
( theWrappedObject->setFileName(fileName));
}
void PythonQtWrapper_QLibrary::setFileNameAndVersion(QLibrary* theWrappedObject, const QString& fileName, const QString& version)
{
( theWrappedObject->setFileNameAndVersion(fileName, version));
}
void PythonQtWrapper_QLibrary::setFileNameAndVersion(QLibrary* theWrappedObject, const QString& fileName, int verNum)
{
( theWrappedObject->setFileNameAndVersion(fileName, verNum));
}
void PythonQtWrapper_QLibrary::setLoadHints(QLibrary* theWrappedObject, QLibrary::LoadHints hints)
{
( theWrappedObject->setLoadHints(hints));
}
bool PythonQtWrapper_QLibrary::unload(QLibrary* theWrappedObject)
{
return ( theWrappedObject->unload());
}
QDate PythonQtWrapper_QLibraryInfo::static_QLibraryInfo_buildDate()
{
return (QLibraryInfo::buildDate());
}
QString PythonQtWrapper_QLibraryInfo::static_QLibraryInfo_buildKey()
{
return (QLibraryInfo::buildKey());
}
QString PythonQtWrapper_QLibraryInfo::static_QLibraryInfo_licensedProducts()
{
return (QLibraryInfo::licensedProducts());
}
QString PythonQtWrapper_QLibraryInfo::static_QLibraryInfo_licensee()
{
return (QLibraryInfo::licensee());
}
QString PythonQtWrapper_QLibraryInfo::static_QLibraryInfo_location(QLibraryInfo::LibraryLocation arg__1)
{
return (QLibraryInfo::location(arg__1));
}