com_trolltech_qt_core2.cpp
2688 lines
| 91.7 KiB
| text/x-c
|
CppLexer
florianlink
|
r110 | #include "com_trolltech_qt_core2.h" | ||
#include <PythonQtConversion.h> | ||||
#include <PythonQtMethodInfo.h> | ||||
#include <PythonQtSignalReceiver.h> | ||||
florianlink
|
r186 | #include <QTextCodec> | ||
florianlink
|
r110 | #include <QVariant> | ||
#include <qanimationgroup.h> | ||||
#include <qbytearray.h> | ||||
#include <qcoreevent.h> | ||||
#include <qdatastream.h> | ||||
#include <qeasingcurve.h> | ||||
florianlink
|
r186 | #include <qfile.h> | ||
#include <qiodevice.h> | ||||
florianlink
|
r110 | #include <qlist.h> | ||
florianlink
|
r186 | #include <qlocale.h> | ||
florianlink
|
r110 | #include <qmutex.h> | ||
#include <qobject.h> | ||||
#include <qpair.h> | ||||
#include <qreadwritelock.h> | ||||
florianlink
|
r186 | #include <qrunnable.h> | ||
#include <qsystemsemaphore.h> | ||||
florianlink
|
r110 | #include <qtconcurrentreducekernel.h> | ||
#include <qtconcurrentthreadengine.h> | ||||
florianlink
|
r186 | #include <qtemporaryfile.h> | ||
#include <qtextboundaryfinder.h> | ||||
#include <qtextcodec.h> | ||||
#include <qtextstream.h> | ||||
#include <qthreadpool.h> | ||||
#include <qtimeline.h> | ||||
#include <qtimer.h> | ||||
florianlink
|
r110 | #include <qtranslator.h> | ||
#include <quuid.h> | ||||
#include <qvariantanimation.h> | ||||
#include <qvector.h> | ||||
#include <qwaitcondition.h> | ||||
florianlink
|
r186 | QSystemSemaphore* PythonQtWrapper_QSystemSemaphore::new_QSystemSemaphore(const QString& key, int initialValue, QSystemSemaphore::AccessMode mode) | ||
{ | ||||
return new QSystemSemaphore(key, initialValue, mode); } | ||||
bool PythonQtWrapper_QSystemSemaphore::acquire(QSystemSemaphore* theWrappedObject) | ||||
{ | ||||
return ( theWrappedObject->acquire()); | ||||
} | ||||
QSystemSemaphore::SystemSemaphoreError PythonQtWrapper_QSystemSemaphore::error(QSystemSemaphore* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->error()); | ||||
} | ||||
QString PythonQtWrapper_QSystemSemaphore::errorString(QSystemSemaphore* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->errorString()); | ||||
} | ||||
QString PythonQtWrapper_QSystemSemaphore::key(QSystemSemaphore* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->key()); | ||||
} | ||||
bool PythonQtWrapper_QSystemSemaphore::release(QSystemSemaphore* theWrappedObject, int n) | ||||
{ | ||||
return ( theWrappedObject->release(n)); | ||||
} | ||||
void PythonQtWrapper_QSystemSemaphore::setKey(QSystemSemaphore* theWrappedObject, const QString& key, int initialValue, QSystemSemaphore::AccessMode mode) | ||||
{ | ||||
( theWrappedObject->setKey(key, initialValue, mode)); | ||||
} | ||||
PythonQtShell_QTemporaryFile::~PythonQtShell_QTemporaryFile() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
bool PythonQtShell_QTemporaryFile::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 QTemporaryFile::atEnd(); | ||||
} | ||||
qint64 PythonQtShell_QTemporaryFile::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 QTemporaryFile::bytesAvailable(); | ||||
} | ||||
qint64 PythonQtShell_QTemporaryFile::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 QTemporaryFile::bytesToWrite(); | ||||
} | ||||
bool PythonQtShell_QTemporaryFile::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 QTemporaryFile::canReadLine(); | ||||
} | ||||
void PythonQtShell_QTemporaryFile::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; | ||||
} | ||||
} | ||||
QTemporaryFile::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTemporaryFile::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; | ||||
} | ||||
} | ||||
QTemporaryFile::close(); | ||||
} | ||||
void PythonQtShell_QTemporaryFile::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; | ||||
} | ||||
} | ||||
QTemporaryFile::customEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QTemporaryFile::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 QTemporaryFile::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QTemporaryFile::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 QTemporaryFile::eventFilter(arg__1, arg__2); | ||||
} | ||||
QAbstractFileEngine* PythonQtShell_QTemporaryFile::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 QTemporaryFile::fileEngine(); | ||||
} | ||||
bool PythonQtShell_QTemporaryFile::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 QTemporaryFile::isSequential(); | ||||
} | ||||
bool PythonQtShell_QTemporaryFile::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 QTemporaryFile::open(flags); | ||||
} | ||||
qint64 PythonQtShell_QTemporaryFile::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 QTemporaryFile::pos(); | ||||
} | ||||
qint64 PythonQtShell_QTemporaryFile::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 QTemporaryFile::readData(data, maxlen); | ||||
} | ||||
qint64 PythonQtShell_QTemporaryFile::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 QTemporaryFile::readLineData(data, maxlen); | ||||
} | ||||
bool PythonQtShell_QTemporaryFile::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 QTemporaryFile::reset(); | ||||
} | ||||
bool PythonQtShell_QTemporaryFile::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 QTemporaryFile::seek(offset); | ||||
} | ||||
qint64 PythonQtShell_QTemporaryFile::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 QTemporaryFile::size(); | ||||
} | ||||
void PythonQtShell_QTemporaryFile::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; | ||||
} | ||||
} | ||||
QTemporaryFile::timerEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QTemporaryFile::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 QTemporaryFile::waitForBytesWritten(msecs); | ||||
} | ||||
bool PythonQtShell_QTemporaryFile::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 QTemporaryFile::waitForReadyRead(msecs); | ||||
} | ||||
qint64 PythonQtShell_QTemporaryFile::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 QTemporaryFile::writeData(data, len); | ||||
} | ||||
QTemporaryFile* PythonQtWrapper_QTemporaryFile::new_QTemporaryFile() | ||||
{ | ||||
return new PythonQtShell_QTemporaryFile(); } | ||||
QTemporaryFile* PythonQtWrapper_QTemporaryFile::new_QTemporaryFile(QObject* parent) | ||||
{ | ||||
return new PythonQtShell_QTemporaryFile(parent); } | ||||
QTemporaryFile* PythonQtWrapper_QTemporaryFile::new_QTemporaryFile(const QString& templateName) | ||||
{ | ||||
return new PythonQtShell_QTemporaryFile(templateName); } | ||||
QTemporaryFile* PythonQtWrapper_QTemporaryFile::new_QTemporaryFile(const QString& templateName, QObject* parent) | ||||
{ | ||||
return new PythonQtShell_QTemporaryFile(templateName, parent); } | ||||
bool PythonQtWrapper_QTemporaryFile::autoRemove(QTemporaryFile* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->autoRemove()); | ||||
} | ||||
QTemporaryFile* PythonQtWrapper_QTemporaryFile::static_QTemporaryFile_createLocalFile(QFile& file) | ||||
{ | ||||
return (QTemporaryFile::createLocalFile(file)); | ||||
} | ||||
QTemporaryFile* PythonQtWrapper_QTemporaryFile::static_QTemporaryFile_createLocalFile(const QString& fileName) | ||||
{ | ||||
return (QTemporaryFile::createLocalFile(fileName)); | ||||
} | ||||
QAbstractFileEngine* PythonQtWrapper_QTemporaryFile::fileEngine(QTemporaryFile* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTemporaryFile*)theWrappedObject)->promoted_fileEngine()); | ||||
} | ||||
QString PythonQtWrapper_QTemporaryFile::fileName(QTemporaryFile* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->fileName()); | ||||
} | ||||
QString PythonQtWrapper_QTemporaryFile::fileTemplate(QTemporaryFile* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->fileTemplate()); | ||||
} | ||||
bool PythonQtWrapper_QTemporaryFile::open(QTemporaryFile* theWrappedObject) | ||||
{ | ||||
return ( theWrappedObject->open()); | ||||
} | ||||
bool PythonQtWrapper_QTemporaryFile::open(QTemporaryFile* theWrappedObject, QIODevice::OpenMode flags) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTemporaryFile*)theWrappedObject)->promoted_open(flags)); | ||||
} | ||||
void PythonQtWrapper_QTemporaryFile::setAutoRemove(QTemporaryFile* theWrappedObject, bool b) | ||||
{ | ||||
( theWrappedObject->setAutoRemove(b)); | ||||
} | ||||
void PythonQtWrapper_QTemporaryFile::setFileTemplate(QTemporaryFile* theWrappedObject, const QString& name) | ||||
{ | ||||
( theWrappedObject->setFileTemplate(name)); | ||||
} | ||||
QTextBoundaryFinder* PythonQtWrapper_QTextBoundaryFinder::new_QTextBoundaryFinder() | ||||
{ | ||||
return new QTextBoundaryFinder(); } | ||||
QTextBoundaryFinder* PythonQtWrapper_QTextBoundaryFinder::new_QTextBoundaryFinder(QTextBoundaryFinder::BoundaryType type, const QString& string) | ||||
{ | ||||
return new QTextBoundaryFinder(type, string); } | ||||
QTextBoundaryFinder* PythonQtWrapper_QTextBoundaryFinder::new_QTextBoundaryFinder(const QTextBoundaryFinder& other) | ||||
{ | ||||
return new QTextBoundaryFinder(other); } | ||||
QTextBoundaryFinder::BoundaryReasons PythonQtWrapper_QTextBoundaryFinder::boundaryReasons(QTextBoundaryFinder* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->boundaryReasons()); | ||||
} | ||||
bool PythonQtWrapper_QTextBoundaryFinder::isAtBoundary(QTextBoundaryFinder* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isAtBoundary()); | ||||
} | ||||
bool PythonQtWrapper_QTextBoundaryFinder::isValid(QTextBoundaryFinder* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isValid()); | ||||
} | ||||
int PythonQtWrapper_QTextBoundaryFinder::position(QTextBoundaryFinder* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->position()); | ||||
} | ||||
void PythonQtWrapper_QTextBoundaryFinder::setPosition(QTextBoundaryFinder* theWrappedObject, int position) | ||||
{ | ||||
( theWrappedObject->setPosition(position)); | ||||
} | ||||
QString PythonQtWrapper_QTextBoundaryFinder::string(QTextBoundaryFinder* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->string()); | ||||
} | ||||
void PythonQtWrapper_QTextBoundaryFinder::toEnd(QTextBoundaryFinder* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->toEnd()); | ||||
} | ||||
int PythonQtWrapper_QTextBoundaryFinder::toNextBoundary(QTextBoundaryFinder* theWrappedObject) | ||||
{ | ||||
return ( theWrappedObject->toNextBoundary()); | ||||
} | ||||
int PythonQtWrapper_QTextBoundaryFinder::toPreviousBoundary(QTextBoundaryFinder* theWrappedObject) | ||||
{ | ||||
return ( theWrappedObject->toPreviousBoundary()); | ||||
} | ||||
void PythonQtWrapper_QTextBoundaryFinder::toStart(QTextBoundaryFinder* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->toStart()); | ||||
} | ||||
QTextBoundaryFinder::BoundaryType PythonQtWrapper_QTextBoundaryFinder::type(QTextBoundaryFinder* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->type()); | ||||
} | ||||
PythonQtShell_QTextCodec::~PythonQtShell_QTextCodec() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
QList<QByteArray > PythonQtShell_QTextCodec::aliases() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "aliases"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QList<QByteArray >"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QList<QByteArray > returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("aliases", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QList<QByteArray >*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTextCodec::aliases(); | ||||
} | ||||
QByteArray PythonQtShell_QTextCodec::convertFromUnicode(const QChar* in, int length, QTextCodec::ConverterState* state) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "convertFromUnicode"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QByteArray" , "const QChar*" , "int" , "QTextCodec::ConverterState*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
QByteArray returnValue; | ||||
void* args[4] = {NULL, (void*)&in, (void*)&length, (void*)&state}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("convertFromUnicode", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QByteArray*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QByteArray(); | ||||
} | ||||
QString PythonQtShell_QTextCodec::convertToUnicode(const char* in, int length, QTextCodec::ConverterState* state) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "convertToUnicode"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QString" , "const char*" , "int" , "QTextCodec::ConverterState*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
QString returnValue; | ||||
void* args[4] = {NULL, (void*)&in, (void*)&length, (void*)&state}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("convertToUnicode", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QString*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QString(); | ||||
} | ||||
int PythonQtShell_QTextCodec::mibEnum() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "mibEnum"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
int returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("mibEnum", methodInfo, result); | ||||
} else { | ||||
returnValue = *((int*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return int(); | ||||
} | ||||
QByteArray PythonQtShell_QTextCodec::name() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "name"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QByteArray"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QByteArray returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("name", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QByteArray*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QByteArray(); | ||||
} | ||||
QList<QByteArray > PythonQtWrapper_QTextCodec::aliases(QTextCodec* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTextCodec*)theWrappedObject)->promoted_aliases()); | ||||
} | ||||
QList<QByteArray > PythonQtWrapper_QTextCodec::static_QTextCodec_availableCodecs() | ||||
{ | ||||
return (QTextCodec::availableCodecs()); | ||||
} | ||||
QList<int > PythonQtWrapper_QTextCodec::static_QTextCodec_availableMibs() | ||||
{ | ||||
return (QTextCodec::availableMibs()); | ||||
} | ||||
bool PythonQtWrapper_QTextCodec::canEncode(QTextCodec* theWrappedObject, QChar arg__1) const | ||||
{ | ||||
return ( theWrappedObject->canEncode(arg__1)); | ||||
} | ||||
bool PythonQtWrapper_QTextCodec::canEncode(QTextCodec* theWrappedObject, const QString& arg__1) const | ||||
{ | ||||
return ( theWrappedObject->canEncode(arg__1)); | ||||
} | ||||
QTextCodec* PythonQtWrapper_QTextCodec::static_QTextCodec_codecForCStrings() | ||||
{ | ||||
return (QTextCodec::codecForCStrings()); | ||||
} | ||||
QTextCodec* PythonQtWrapper_QTextCodec::static_QTextCodec_codecForHtml(const QByteArray& ba) | ||||
{ | ||||
return (QTextCodec::codecForHtml(ba)); | ||||
} | ||||
QTextCodec* PythonQtWrapper_QTextCodec::static_QTextCodec_codecForHtml(const QByteArray& ba, QTextCodec* defaultCodec) | ||||
{ | ||||
return (QTextCodec::codecForHtml(ba, defaultCodec)); | ||||
} | ||||
QTextCodec* PythonQtWrapper_QTextCodec::static_QTextCodec_codecForLocale() | ||||
{ | ||||
return (QTextCodec::codecForLocale()); | ||||
} | ||||
QTextCodec* PythonQtWrapper_QTextCodec::static_QTextCodec_codecForMib(int mib) | ||||
{ | ||||
return (QTextCodec::codecForMib(mib)); | ||||
} | ||||
QTextCodec* PythonQtWrapper_QTextCodec::static_QTextCodec_codecForName(const QByteArray& name) | ||||
{ | ||||
return (QTextCodec::codecForName(name)); | ||||
} | ||||
QTextCodec* PythonQtWrapper_QTextCodec::static_QTextCodec_codecForName(const char* name) | ||||
{ | ||||
return (QTextCodec::codecForName(name)); | ||||
} | ||||
QTextCodec* PythonQtWrapper_QTextCodec::static_QTextCodec_codecForUtfText(const QByteArray& ba) | ||||
{ | ||||
return (QTextCodec::codecForUtfText(ba)); | ||||
} | ||||
QTextCodec* PythonQtWrapper_QTextCodec::static_QTextCodec_codecForUtfText(const QByteArray& ba, QTextCodec* defaultCodec) | ||||
{ | ||||
return (QTextCodec::codecForUtfText(ba, defaultCodec)); | ||||
} | ||||
QByteArray PythonQtWrapper_QTextCodec::fromUnicode(QTextCodec* theWrappedObject, const QString& uc) const | ||||
{ | ||||
return ( theWrappedObject->fromUnicode(uc)); | ||||
} | ||||
QTextDecoder* PythonQtWrapper_QTextCodec::makeDecoder(QTextCodec* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->makeDecoder()); | ||||
} | ||||
QTextDecoder* PythonQtWrapper_QTextCodec::makeDecoder(QTextCodec* theWrappedObject, QTextCodec::ConversionFlags flags) const | ||||
{ | ||||
return ( theWrappedObject->makeDecoder(flags)); | ||||
} | ||||
QTextEncoder* PythonQtWrapper_QTextCodec::makeEncoder(QTextCodec* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->makeEncoder()); | ||||
} | ||||
QTextEncoder* PythonQtWrapper_QTextCodec::makeEncoder(QTextCodec* theWrappedObject, QTextCodec::ConversionFlags flags) const | ||||
{ | ||||
return ( theWrappedObject->makeEncoder(flags)); | ||||
} | ||||
void PythonQtWrapper_QTextCodec::static_QTextCodec_setCodecForCStrings(QTextCodec* c) | ||||
{ | ||||
(QTextCodec::setCodecForCStrings(c)); | ||||
} | ||||
void PythonQtWrapper_QTextCodec::static_QTextCodec_setCodecForLocale(QTextCodec* c) | ||||
{ | ||||
(QTextCodec::setCodecForLocale(c)); | ||||
} | ||||
void PythonQtWrapper_QTextCodec::static_QTextCodec_setCodecForTr(QTextCodec* c) | ||||
{ | ||||
(QTextCodec::setCodecForTr(c)); | ||||
} | ||||
QString PythonQtWrapper_QTextCodec::toUnicode(QTextCodec* theWrappedObject, const QByteArray& arg__1) const | ||||
{ | ||||
return ( theWrappedObject->toUnicode(arg__1)); | ||||
} | ||||
QTextDecoder* PythonQtWrapper_QTextDecoder::new_QTextDecoder(const QTextCodec* codec) | ||||
{ | ||||
return new QTextDecoder(codec); } | ||||
QTextDecoder* PythonQtWrapper_QTextDecoder::new_QTextDecoder(const QTextCodec* codec, QTextCodec::ConversionFlags flags) | ||||
{ | ||||
return new QTextDecoder(codec, flags); } | ||||
bool PythonQtWrapper_QTextDecoder::hasFailure(QTextDecoder* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->hasFailure()); | ||||
} | ||||
QString PythonQtWrapper_QTextDecoder::toUnicode(QTextDecoder* theWrappedObject, const QByteArray& ba) | ||||
{ | ||||
return ( theWrappedObject->toUnicode(ba)); | ||||
} | ||||
QTextEncoder* PythonQtWrapper_QTextEncoder::new_QTextEncoder(const QTextCodec* codec) | ||||
{ | ||||
return new QTextEncoder(codec); } | ||||
QTextEncoder* PythonQtWrapper_QTextEncoder::new_QTextEncoder(const QTextCodec* codec, QTextCodec::ConversionFlags flags) | ||||
{ | ||||
return new QTextEncoder(codec, flags); } | ||||
QByteArray PythonQtWrapper_QTextEncoder::fromUnicode(QTextEncoder* theWrappedObject, const QString& str) | ||||
{ | ||||
return ( theWrappedObject->fromUnicode(str)); | ||||
} | ||||
bool PythonQtWrapper_QTextEncoder::hasFailure(QTextEncoder* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->hasFailure()); | ||||
} | ||||
PythonQtShell_QTextStream::~PythonQtShell_QTextStream() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
QTextStream* PythonQtWrapper_QTextStream::new_QTextStream() | ||||
{ | ||||
return new PythonQtShell_QTextStream(); } | ||||
QTextStream* PythonQtWrapper_QTextStream::new_QTextStream(QIODevice* device) | ||||
{ | ||||
return new PythonQtShell_QTextStream(device); } | ||||
QTextStream* PythonQtWrapper_QTextStream::new_QTextStream(const QByteArray& array, QIODevice::OpenMode openMode) | ||||
{ | ||||
return new PythonQtShell_QTextStream(array, openMode); } | ||||
bool PythonQtWrapper_QTextStream::atEnd(QTextStream* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->atEnd()); | ||||
} | ||||
bool PythonQtWrapper_QTextStream::autoDetectUnicode(QTextStream* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->autoDetectUnicode()); | ||||
} | ||||
QTextCodec* PythonQtWrapper_QTextStream::codec(QTextStream* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->codec()); | ||||
} | ||||
QIODevice* PythonQtWrapper_QTextStream::device(QTextStream* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->device()); | ||||
} | ||||
QTextStream::FieldAlignment PythonQtWrapper_QTextStream::fieldAlignment(QTextStream* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->fieldAlignment()); | ||||
} | ||||
int PythonQtWrapper_QTextStream::fieldWidth(QTextStream* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->fieldWidth()); | ||||
} | ||||
void PythonQtWrapper_QTextStream::flush(QTextStream* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->flush()); | ||||
} | ||||
bool PythonQtWrapper_QTextStream::generateByteOrderMark(QTextStream* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->generateByteOrderMark()); | ||||
} | ||||
int PythonQtWrapper_QTextStream::integerBase(QTextStream* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->integerBase()); | ||||
} | ||||
QLocale PythonQtWrapper_QTextStream::locale(QTextStream* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->locale()); | ||||
} | ||||
QTextStream::NumberFlags PythonQtWrapper_QTextStream::numberFlags(QTextStream* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->numberFlags()); | ||||
} | ||||
QTextStream* PythonQtWrapper_QTextStream::writeBoolean(QTextStream* theWrappedObject, QBool b) | ||||
{ | ||||
return &( (*theWrappedObject) <<b); | ||||
} | ||||
QTextStream* PythonQtWrapper_QTextStream::writeByte(QTextStream* theWrappedObject, char ch) | ||||
{ | ||||
return &( (*theWrappedObject) <<ch); | ||||
} | ||||
QTextStream* PythonQtWrapper_QTextStream::writeDouble(QTextStream* theWrappedObject, double f) | ||||
{ | ||||
return &( (*theWrappedObject) <<f); | ||||
} | ||||
QTextStream* PythonQtWrapper_QTextStream::writeFloat(QTextStream* theWrappedObject, float f) | ||||
{ | ||||
return &( (*theWrappedObject) <<f); | ||||
} | ||||
QTextStream* PythonQtWrapper_QTextStream::writeLongLong(QTextStream* theWrappedObject, qlonglong i) | ||||
{ | ||||
return &( (*theWrappedObject) <<i); | ||||
} | ||||
QTextStream* PythonQtWrapper_QTextStream::writeInt(QTextStream* theWrappedObject, signed int i) | ||||
{ | ||||
return &( (*theWrappedObject) <<i); | ||||
} | ||||
QTextStream* PythonQtWrapper_QTextStream::writeShort(QTextStream* theWrappedObject, signed short i) | ||||
{ | ||||
return &( (*theWrappedObject) <<i); | ||||
} | ||||
QTextStream* PythonQtWrapper_QTextStream::readByte(QTextStream* theWrappedObject, char& ch) | ||||
{ | ||||
return &( (*theWrappedObject) >>ch); | ||||
} | ||||
QTextStream* PythonQtWrapper_QTextStream::readDouble(QTextStream* theWrappedObject, double& f) | ||||
{ | ||||
return &( (*theWrappedObject) >>f); | ||||
} | ||||
QTextStream* PythonQtWrapper_QTextStream::readFloat(QTextStream* theWrappedObject, float& f) | ||||
{ | ||||
return &( (*theWrappedObject) >>f); | ||||
} | ||||
QTextStream* PythonQtWrapper_QTextStream::readLongLong(QTextStream* theWrappedObject, qlonglong& i) | ||||
{ | ||||
return &( (*theWrappedObject) >>i); | ||||
} | ||||
QTextStream* PythonQtWrapper_QTextStream::readInt(QTextStream* theWrappedObject, signed int& i) | ||||
{ | ||||
return &( (*theWrappedObject) >>i); | ||||
} | ||||
QTextStream* PythonQtWrapper_QTextStream::readShort(QTextStream* theWrappedObject, signed short& i) | ||||
{ | ||||
return &( (*theWrappedObject) >>i); | ||||
} | ||||
QChar PythonQtWrapper_QTextStream::padChar(QTextStream* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->padChar()); | ||||
} | ||||
qint64 PythonQtWrapper_QTextStream::pos(QTextStream* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->pos()); | ||||
} | ||||
QString PythonQtWrapper_QTextStream::read(QTextStream* theWrappedObject, qint64 maxlen) | ||||
{ | ||||
return ( theWrappedObject->read(maxlen)); | ||||
} | ||||
QString PythonQtWrapper_QTextStream::readAll(QTextStream* theWrappedObject) | ||||
{ | ||||
return ( theWrappedObject->readAll()); | ||||
} | ||||
QString PythonQtWrapper_QTextStream::readLine(QTextStream* theWrappedObject, qint64 maxlen) | ||||
{ | ||||
return ( theWrappedObject->readLine(maxlen)); | ||||
} | ||||
QTextStream::RealNumberNotation PythonQtWrapper_QTextStream::realNumberNotation(QTextStream* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->realNumberNotation()); | ||||
} | ||||
int PythonQtWrapper_QTextStream::realNumberPrecision(QTextStream* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->realNumberPrecision()); | ||||
} | ||||
void PythonQtWrapper_QTextStream::reset(QTextStream* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->reset()); | ||||
} | ||||
void PythonQtWrapper_QTextStream::resetStatus(QTextStream* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->resetStatus()); | ||||
} | ||||
bool PythonQtWrapper_QTextStream::seek(QTextStream* theWrappedObject, qint64 pos) | ||||
{ | ||||
return ( theWrappedObject->seek(pos)); | ||||
} | ||||
void PythonQtWrapper_QTextStream::setAutoDetectUnicode(QTextStream* theWrappedObject, bool enabled) | ||||
{ | ||||
( theWrappedObject->setAutoDetectUnicode(enabled)); | ||||
} | ||||
void PythonQtWrapper_QTextStream::setCodec(QTextStream* theWrappedObject, QTextCodec* codec) | ||||
{ | ||||
( theWrappedObject->setCodec(codec)); | ||||
} | ||||
void PythonQtWrapper_QTextStream::setCodec(QTextStream* theWrappedObject, const char* codecName) | ||||
{ | ||||
( theWrappedObject->setCodec(codecName)); | ||||
} | ||||
void PythonQtWrapper_QTextStream::setDevice(QTextStream* theWrappedObject, QIODevice* device) | ||||
{ | ||||
( theWrappedObject->setDevice(device)); | ||||
} | ||||
void PythonQtWrapper_QTextStream::setFieldAlignment(QTextStream* theWrappedObject, QTextStream::FieldAlignment alignment) | ||||
{ | ||||
( theWrappedObject->setFieldAlignment(alignment)); | ||||
} | ||||
void PythonQtWrapper_QTextStream::setFieldWidth(QTextStream* theWrappedObject, int width) | ||||
{ | ||||
( theWrappedObject->setFieldWidth(width)); | ||||
} | ||||
void PythonQtWrapper_QTextStream::setGenerateByteOrderMark(QTextStream* theWrappedObject, bool generate) | ||||
{ | ||||
( theWrappedObject->setGenerateByteOrderMark(generate)); | ||||
} | ||||
void PythonQtWrapper_QTextStream::setIntegerBase(QTextStream* theWrappedObject, int base) | ||||
{ | ||||
( theWrappedObject->setIntegerBase(base)); | ||||
} | ||||
void PythonQtWrapper_QTextStream::setLocale(QTextStream* theWrappedObject, const QLocale& locale) | ||||
{ | ||||
( theWrappedObject->setLocale(locale)); | ||||
} | ||||
void PythonQtWrapper_QTextStream::setNumberFlags(QTextStream* theWrappedObject, QTextStream::NumberFlags flags) | ||||
{ | ||||
( theWrappedObject->setNumberFlags(flags)); | ||||
} | ||||
void PythonQtWrapper_QTextStream::setPadChar(QTextStream* theWrappedObject, QChar ch) | ||||
{ | ||||
( theWrappedObject->setPadChar(ch)); | ||||
} | ||||
void PythonQtWrapper_QTextStream::setRealNumberNotation(QTextStream* theWrappedObject, QTextStream::RealNumberNotation notation) | ||||
{ | ||||
( theWrappedObject->setRealNumberNotation(notation)); | ||||
} | ||||
void PythonQtWrapper_QTextStream::setRealNumberPrecision(QTextStream* theWrappedObject, int precision) | ||||
{ | ||||
( theWrappedObject->setRealNumberPrecision(precision)); | ||||
} | ||||
void PythonQtWrapper_QTextStream::setStatus(QTextStream* theWrappedObject, QTextStream::Status status) | ||||
{ | ||||
( theWrappedObject->setStatus(status)); | ||||
} | ||||
void PythonQtWrapper_QTextStream::skipWhiteSpace(QTextStream* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->skipWhiteSpace()); | ||||
} | ||||
QTextStream::Status PythonQtWrapper_QTextStream::status(QTextStream* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->status()); | ||||
} | ||||
PythonQtShell_QThreadPool::~PythonQtShell_QThreadPool() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_QThreadPool::childEvent(QChildEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QChildEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QThreadPool::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QThreadPool::customEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QThreadPool::customEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QThreadPool::event(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "QEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QThreadPool::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QThreadPool::eventFilter(QObject* arg__1, QEvent* arg__2) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
bool returnValue; | ||||
void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QThreadPool::eventFilter(arg__1, arg__2); | ||||
} | ||||
void PythonQtShell_QThreadPool::timerEvent(QTimerEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QTimerEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QThreadPool::timerEvent(arg__1); | ||||
} | ||||
QThreadPool* PythonQtWrapper_QThreadPool::new_QThreadPool(QObject* parent) | ||||
{ | ||||
return new PythonQtShell_QThreadPool(parent); } | ||||
int PythonQtWrapper_QThreadPool::activeThreadCount(QThreadPool* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->activeThreadCount()); | ||||
} | ||||
int PythonQtWrapper_QThreadPool::expiryTimeout(QThreadPool* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->expiryTimeout()); | ||||
} | ||||
QThreadPool* PythonQtWrapper_QThreadPool::static_QThreadPool_globalInstance() | ||||
{ | ||||
return (QThreadPool::globalInstance()); | ||||
} | ||||
int PythonQtWrapper_QThreadPool::maxThreadCount(QThreadPool* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->maxThreadCount()); | ||||
} | ||||
void PythonQtWrapper_QThreadPool::releaseThread(QThreadPool* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->releaseThread()); | ||||
} | ||||
void PythonQtWrapper_QThreadPool::reserveThread(QThreadPool* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->reserveThread()); | ||||
} | ||||
void PythonQtWrapper_QThreadPool::setExpiryTimeout(QThreadPool* theWrappedObject, int expiryTimeout) | ||||
{ | ||||
( theWrappedObject->setExpiryTimeout(expiryTimeout)); | ||||
} | ||||
void PythonQtWrapper_QThreadPool::setMaxThreadCount(QThreadPool* theWrappedObject, int maxThreadCount) | ||||
{ | ||||
( theWrappedObject->setMaxThreadCount(maxThreadCount)); | ||||
} | ||||
void PythonQtWrapper_QThreadPool::start(QThreadPool* theWrappedObject, QRunnable* runnable, int priority) | ||||
{ | ||||
( theWrappedObject->start(runnable, priority)); | ||||
} | ||||
bool PythonQtWrapper_QThreadPool::tryStart(QThreadPool* theWrappedObject, QRunnable* runnable) | ||||
{ | ||||
return ( theWrappedObject->tryStart(runnable)); | ||||
} | ||||
void PythonQtWrapper_QThreadPool::waitForDone(QThreadPool* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->waitForDone()); | ||||
} | ||||
bool PythonQtWrapper_QThreadPool::waitForDone(QThreadPool* theWrappedObject, int msecs) | ||||
{ | ||||
return ( theWrappedObject->waitForDone(msecs)); | ||||
} | ||||
PythonQtShell_QTimeLine::~PythonQtShell_QTimeLine() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_QTimeLine::childEvent(QChildEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QChildEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTimeLine::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTimeLine::customEvent(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTimeLine::customEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QTimeLine::event(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "QEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTimeLine::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QTimeLine::eventFilter(QObject* arg__1, QEvent* arg__2) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
bool returnValue; | ||||
void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTimeLine::eventFilter(arg__1, arg__2); | ||||
} | ||||
void PythonQtShell_QTimeLine::timerEvent(QTimerEvent* event) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QTimerEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&event}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTimeLine::timerEvent(event); | ||||
} | ||||
qreal PythonQtShell_QTimeLine::valueForTime(int msec) const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "valueForTime"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"qreal" , "int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
qreal returnValue; | ||||
void* args[2] = {NULL, (void*)&msec}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("valueForTime", methodInfo, result); | ||||
} else { | ||||
returnValue = *((qreal*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTimeLine::valueForTime(msec); | ||||
} | ||||
QTimeLine* PythonQtWrapper_QTimeLine::new_QTimeLine(int duration, QObject* parent) | ||||
{ | ||||
return new PythonQtShell_QTimeLine(duration, parent); } | ||||
int PythonQtWrapper_QTimeLine::currentFrame(QTimeLine* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->currentFrame()); | ||||
} | ||||
int PythonQtWrapper_QTimeLine::currentTime(QTimeLine* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->currentTime()); | ||||
} | ||||
qreal PythonQtWrapper_QTimeLine::currentValue(QTimeLine* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->currentValue()); | ||||
} | ||||
QTimeLine::CurveShape PythonQtWrapper_QTimeLine::curveShape(QTimeLine* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->curveShape()); | ||||
} | ||||
QTimeLine::Direction PythonQtWrapper_QTimeLine::direction(QTimeLine* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->direction()); | ||||
} | ||||
int PythonQtWrapper_QTimeLine::duration(QTimeLine* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->duration()); | ||||
} | ||||
QEasingCurve PythonQtWrapper_QTimeLine::easingCurve(QTimeLine* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->easingCurve()); | ||||
} | ||||
int PythonQtWrapper_QTimeLine::endFrame(QTimeLine* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->endFrame()); | ||||
} | ||||
int PythonQtWrapper_QTimeLine::frameForTime(QTimeLine* theWrappedObject, int msec) const | ||||
{ | ||||
return ( theWrappedObject->frameForTime(msec)); | ||||
} | ||||
int PythonQtWrapper_QTimeLine::loopCount(QTimeLine* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->loopCount()); | ||||
} | ||||
void PythonQtWrapper_QTimeLine::setCurveShape(QTimeLine* theWrappedObject, QTimeLine::CurveShape shape) | ||||
{ | ||||
( theWrappedObject->setCurveShape(shape)); | ||||
} | ||||
void PythonQtWrapper_QTimeLine::setDirection(QTimeLine* theWrappedObject, QTimeLine::Direction direction) | ||||
{ | ||||
( theWrappedObject->setDirection(direction)); | ||||
} | ||||
void PythonQtWrapper_QTimeLine::setDuration(QTimeLine* theWrappedObject, int duration) | ||||
{ | ||||
( theWrappedObject->setDuration(duration)); | ||||
} | ||||
void PythonQtWrapper_QTimeLine::setEasingCurve(QTimeLine* theWrappedObject, const QEasingCurve& curve) | ||||
{ | ||||
( theWrappedObject->setEasingCurve(curve)); | ||||
} | ||||
void PythonQtWrapper_QTimeLine::setEndFrame(QTimeLine* theWrappedObject, int frame) | ||||
{ | ||||
( theWrappedObject->setEndFrame(frame)); | ||||
} | ||||
void PythonQtWrapper_QTimeLine::setFrameRange(QTimeLine* theWrappedObject, int startFrame, int endFrame) | ||||
{ | ||||
( theWrappedObject->setFrameRange(startFrame, endFrame)); | ||||
} | ||||
void PythonQtWrapper_QTimeLine::setLoopCount(QTimeLine* theWrappedObject, int count) | ||||
{ | ||||
( theWrappedObject->setLoopCount(count)); | ||||
} | ||||
void PythonQtWrapper_QTimeLine::setStartFrame(QTimeLine* theWrappedObject, int frame) | ||||
{ | ||||
( theWrappedObject->setStartFrame(frame)); | ||||
} | ||||
void PythonQtWrapper_QTimeLine::setUpdateInterval(QTimeLine* theWrappedObject, int interval) | ||||
{ | ||||
( theWrappedObject->setUpdateInterval(interval)); | ||||
} | ||||
int PythonQtWrapper_QTimeLine::startFrame(QTimeLine* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->startFrame()); | ||||
} | ||||
QTimeLine::State PythonQtWrapper_QTimeLine::state(QTimeLine* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->state()); | ||||
} | ||||
void PythonQtWrapper_QTimeLine::timerEvent(QTimeLine* theWrappedObject, QTimerEvent* event) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTimeLine*)theWrappedObject)->promoted_timerEvent(event)); | ||||
} | ||||
int PythonQtWrapper_QTimeLine::updateInterval(QTimeLine* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->updateInterval()); | ||||
} | ||||
qreal PythonQtWrapper_QTimeLine::valueForTime(QTimeLine* theWrappedObject, int msec) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTimeLine*)theWrappedObject)->promoted_valueForTime(msec)); | ||||
} | ||||
PythonQtShell_QTimer::~PythonQtShell_QTimer() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_QTimer::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; | ||||
} | ||||
} | ||||
QTimer::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QTimer::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; | ||||
} | ||||
} | ||||
QTimer::customEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QTimer::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 QTimer::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QTimer::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 QTimer::eventFilter(arg__1, arg__2); | ||||
} | ||||
void PythonQtShell_QTimer::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; | ||||
} | ||||
} | ||||
QTimer::timerEvent(arg__1); | ||||
} | ||||
QTimer* PythonQtWrapper_QTimer::new_QTimer(QObject* parent) | ||||
{ | ||||
return new PythonQtShell_QTimer(parent); } | ||||
int PythonQtWrapper_QTimer::interval(QTimer* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->interval()); | ||||
} | ||||
bool PythonQtWrapper_QTimer::isActive(QTimer* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isActive()); | ||||
} | ||||
bool PythonQtWrapper_QTimer::isSingleShot(QTimer* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isSingleShot()); | ||||
} | ||||
void PythonQtWrapper_QTimer::setInterval(QTimer* theWrappedObject, int msec) | ||||
{ | ||||
( theWrappedObject->setInterval(msec)); | ||||
} | ||||
void PythonQtWrapper_QTimer::setSingleShot(QTimer* theWrappedObject, bool singleShot) | ||||
{ | ||||
( theWrappedObject->setSingleShot(singleShot)); | ||||
} | ||||
void PythonQtWrapper_QTimer::static_QTimer_singleShot(int msec, QObject* receiver, const char* member) | ||||
{ | ||||
(QTimer::singleShot(msec, receiver, member)); | ||||
} | ||||
void PythonQtWrapper_QTimer::timerEvent(QTimer* theWrappedObject, QTimerEvent* arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTimer*)theWrappedObject)->promoted_timerEvent(arg__1)); | ||||
} | ||||
int PythonQtWrapper_QTimer::timerId(QTimer* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->timerId()); | ||||
} | ||||
PythonQtShell_QTimerEvent::~PythonQtShell_QTimerEvent() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
florianlink
|
r128 | QTimerEvent* PythonQtWrapper_QTimerEvent::new_QTimerEvent(int timerId) | ||
{ | ||||
return new PythonQtShell_QTimerEvent(timerId); } | ||||
int PythonQtWrapper_QTimerEvent::timerId(QTimerEvent* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->timerId()); | ||||
} | ||||
florianlink
|
r186 | PythonQtShell_QTranslator::~PythonQtShell_QTranslator() { | ||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
florianlink
|
r128 | void PythonQtShell_QTranslator::childEvent(QChildEvent* arg__1) | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "QChildEvent*"}; | ||
florianlink
|
r110 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r128 | QTranslator::childEvent(arg__1); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtShell_QTranslator::customEvent(QEvent* arg__1) | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "QEvent*"}; | ||
florianlink
|
r110 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
florianlink
|
r128 | return; | ||
florianlink
|
r110 | } | ||
} | ||||
florianlink
|
r128 | QTranslator::customEvent(arg__1); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | bool PythonQtShell_QTranslator::event(QEvent* arg__1) | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"bool" , "QEvent*"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
florianlink
|
r110 | bool returnValue; | ||
florianlink
|
r128 | void* args[2] = {NULL, (void*)&arg__1}; | ||
florianlink
|
r110 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result); | ||
florianlink
|
r110 | } else { | ||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QTranslator::event(arg__1); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | bool PythonQtShell_QTranslator::eventFilter(QObject* arg__1, QEvent* arg__2) | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | 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}; | ||||
florianlink
|
r110 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result); | ||
florianlink
|
r110 | } else { | ||
florianlink
|
r128 | returnValue = *((bool*)args[0]); | ||
florianlink
|
r110 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QTranslator::eventFilter(arg__1, arg__2); | ||
florianlink
|
r110 | } | ||
bool PythonQtShell_QTranslator::isEmpty() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isEmpty"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
bool returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("isEmpty", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTranslator::isEmpty(); | ||||
} | ||||
florianlink
|
r128 | void PythonQtShell_QTranslator::timerEvent(QTimerEvent* arg__1) | ||
florianlink
|
r117 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent"); | ||
florianlink
|
r117 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "QTimerEvent*"}; | ||
florianlink
|
r117 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
florianlink
|
r128 | return; | ||
florianlink
|
r117 | } | ||
} | ||||
florianlink
|
r128 | QTranslator::timerEvent(arg__1); | ||
florianlink
|
r117 | } | ||
florianlink
|
r128 | QString PythonQtShell_QTranslator::translate(const char* context, const char* sourceText, const char* disambiguation) const | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "translate"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"QString" , "const char*" , "const char*" , "const char*"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
QString returnValue; | ||||
void* args[4] = {NULL, (void*)&context, (void*)&sourceText, (void*)&disambiguation}; | ||||
florianlink
|
r110 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
florianlink
|
r120 | if (result) { | ||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("translate", methodInfo, result); | ||
florianlink
|
r120 | } else { | ||
florianlink
|
r128 | returnValue = *((QString*)args[0]); | ||
florianlink
|
r120 | } | ||
} | ||||
} | ||||
florianlink
|
r110 | if (result) { Py_DECREF(result); } | ||
Py_DECREF(obj); | ||||
florianlink
|
r120 | return returnValue; | ||
florianlink
|
r110 | } | ||
} | ||||
florianlink
|
r128 | return QTranslator::translate(context, sourceText, disambiguation); | ||
florianlink
|
r110 | } | ||
QTranslator* PythonQtWrapper_QTranslator::new_QTranslator(QObject* parent) | ||||
{ | ||||
return new PythonQtShell_QTranslator(parent); } | ||||
florianlink
|
r128 | bool PythonQtWrapper_QTranslator::isEmpty(QTranslator* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QTranslator*)theWrappedObject)->promoted_isEmpty()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r186 | bool PythonQtWrapper_QTranslator::load(QTranslator* theWrappedObject, const QLocale& locale, const QString& filename, const QString& prefix, const QString& directory, const QString& suffix) | ||
{ | ||||
return ( theWrappedObject->load(locale, filename, prefix, directory, suffix)); | ||||
} | ||||
florianlink
|
r110 | bool PythonQtWrapper_QTranslator::load(QTranslator* theWrappedObject, const QString& filename, const QString& directory, const QString& search_delimiters, const QString& suffix) | ||
{ | ||||
return ( theWrappedObject->load(filename, directory, search_delimiters, suffix)); | ||||
} | ||||
florianlink
|
r128 | bool PythonQtWrapper_QTranslator::load(QTranslator* theWrappedObject, const uchar* data, int len) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->load(data, len)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | QString PythonQtWrapper_QTranslator::translate(QTranslator* theWrappedObject, const char* context, const char* sourceText, const char* disambiguation) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QTranslator*)theWrappedObject)->promoted_translate(context, sourceText, disambiguation)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r186 | PythonQtShell_QUuid::~PythonQtShell_QUuid() { | ||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
florianlink
|
r110 | QUuid* PythonQtWrapper_QUuid::new_QUuid() | ||
{ | ||||
return new PythonQtShell_QUuid(); } | ||||
florianlink
|
r186 | QUuid* PythonQtWrapper_QUuid::new_QUuid(const QByteArray& arg__1) | ||
{ | ||||
return new PythonQtShell_QUuid(arg__1); } | ||||
florianlink
|
r110 | QUuid* PythonQtWrapper_QUuid::new_QUuid(const QString& arg__1) | ||
{ | ||||
return new PythonQtShell_QUuid(arg__1); } | ||||
QUuid* PythonQtWrapper_QUuid::new_QUuid(uint l, ushort w1, ushort w2, uchar b1, uchar b2, uchar b3, uchar b4, uchar b5, uchar b6, uchar b7, uchar b8) | ||||
{ | ||||
return new PythonQtShell_QUuid(l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8); } | ||||
florianlink
|
r128 | QUuid PythonQtWrapper_QUuid::static_QUuid_createUuid() | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return (QUuid::createUuid()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r186 | QUuid PythonQtWrapper_QUuid::static_QUuid_fromRfc4122(const QByteArray& arg__1) | ||
{ | ||||
return (QUuid::fromRfc4122(arg__1)); | ||||
} | ||||
florianlink
|
r128 | bool PythonQtWrapper_QUuid::isNull(QUuid* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->isNull()); | ||
florianlink
|
r120 | } | ||
bool PythonQtWrapper_QUuid::__ne__(QUuid* theWrappedObject, const QUuid& orig) const | ||||
{ | ||||
return ( (*theWrappedObject)!= orig); | ||||
florianlink
|
r110 | } | ||
florianlink
|
r120 | bool PythonQtWrapper_QUuid::__lt__(QUuid* theWrappedObject, const QUuid& other) const | ||
florianlink
|
r110 | { | ||
return ( (*theWrappedObject)< other); | ||||
} | ||||
florianlink
|
r128 | void PythonQtWrapper_QUuid::writeTo(QUuid* theWrappedObject, QDataStream& arg__1) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | arg__1 << (*theWrappedObject); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QUuid::__eq__(QUuid* theWrappedObject, const QUuid& orig) const | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | return ( (*theWrappedObject)== orig); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QUuid::__gt__(QUuid* theWrappedObject, const QUuid& other) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( (*theWrappedObject)> other); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QUuid::readFrom(QUuid* theWrappedObject, QDataStream& arg__1) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | arg__1 >> (*theWrappedObject); | ||
florianlink
|
r110 | } | ||
florianlink
|
r186 | QByteArray PythonQtWrapper_QUuid::toByteArray(QUuid* theWrappedObject) const | ||
{ | ||||
return ( theWrappedObject->toByteArray()); | ||||
} | ||||
QByteArray PythonQtWrapper_QUuid::toRfc4122(QUuid* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->toRfc4122()); | ||||
} | ||||
florianlink
|
r128 | QString PythonQtWrapper_QUuid::toString(QUuid* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->toString()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | QUuid::Variant PythonQtWrapper_QUuid::variant(QUuid* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->variant()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | QUuid::Version PythonQtWrapper_QUuid::version(QUuid* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->version()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r117 | QString PythonQtWrapper_QUuid::py_toString(QUuid* obj) { return obj->toString(); } | ||
florianlink
|
r110 | |||
florianlink
|
r186 | PythonQtShell_QVariantAnimation::~PythonQtShell_QVariantAnimation() { | ||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
florianlink
|
r128 | void PythonQtShell_QVariantAnimation::childEvent(QChildEvent* arg__1) | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | 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); | ||||
florianlink
|
r110 | if (result) { Py_DECREF(result); } | ||
Py_DECREF(obj); | ||||
florianlink
|
r128 | return; | ||
florianlink
|
r110 | } | ||
} | ||||
florianlink
|
r128 | QVariantAnimation::childEvent(arg__1); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtShell_QVariantAnimation::customEvent(QEvent* arg__1) | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "QEvent*"}; | ||
florianlink
|
r120 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r128 | void* args[2] = {NULL, (void*)&arg__1}; | ||
florianlink
|
r110 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
florianlink
|
r120 | return; | ||
florianlink
|
r110 | } | ||
} | ||||
florianlink
|
r128 | QVariantAnimation::customEvent(arg__1); | ||
florianlink
|
r110 | } | ||
florianlink
|
r120 | int PythonQtShell_QVariantAnimation::duration() const | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r120 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "duration"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r120 | static const char* argumentList[] ={"int"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
int returnValue; | ||||
void* args[1] = {NULL}; | ||||
florianlink
|
r110 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r120 | PythonQt::priv()->handleVirtualOverloadReturnError("duration", methodInfo, result); | ||
florianlink
|
r110 | } else { | ||
florianlink
|
r120 | returnValue = *((int*)args[0]); | ||
florianlink
|
r110 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r120 | return QVariantAnimation::duration(); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | bool PythonQtShell_QVariantAnimation::event(QEvent* event) | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"bool" , "QEvent*"}; | ||
florianlink
|
r110 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r128 | bool returnValue; | ||
void* args[2] = {NULL, (void*)&event}; | ||||
florianlink
|
r110 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
florianlink
|
r128 | if (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]); | ||||
} | ||||
} | ||||
} | ||||
florianlink
|
r110 | if (result) { Py_DECREF(result); } | ||
Py_DECREF(obj); | ||||
florianlink
|
r128 | return returnValue; | ||
florianlink
|
r110 | } | ||
} | ||||
florianlink
|
r128 | return QVariantAnimation::event(event); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | bool PythonQtShell_QVariantAnimation::eventFilter(QObject* arg__1, QEvent* arg__2) | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | 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}; | ||||
florianlink
|
r110 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
florianlink
|
r120 | if (result) { | ||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result); | ||
florianlink
|
r120 | } else { | ||
florianlink
|
r128 | returnValue = *((bool*)args[0]); | ||
florianlink
|
r120 | } | ||
} | ||||
} | ||||
florianlink
|
r110 | if (result) { Py_DECREF(result); } | ||
Py_DECREF(obj); | ||||
florianlink
|
r120 | return returnValue; | ||
florianlink
|
r110 | } | ||
} | ||||
florianlink
|
r128 | return QVariantAnimation::eventFilter(arg__1, arg__2); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | QVariant PythonQtShell_QVariantAnimation::interpolated(const QVariant& from, const QVariant& to, qreal progress) const | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "interpolated"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"QVariant" , "const QVariant&" , "const QVariant&" , "qreal"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
QVariant returnValue; | ||||
void* args[4] = {NULL, (void*)&from, (void*)&to, (void*)&progress}; | ||||
florianlink
|
r110 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
florianlink
|
r128 | if (result) { | ||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("interpolated", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QVariant*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
florianlink
|
r110 | if (result) { Py_DECREF(result); } | ||
Py_DECREF(obj); | ||||
florianlink
|
r128 | return returnValue; | ||
florianlink
|
r110 | } | ||
} | ||||
florianlink
|
r128 | return QVariantAnimation::interpolated(from, to, progress); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtShell_QVariantAnimation::timerEvent(QTimerEvent* arg__1) | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "QTimerEvent*"}; | ||
florianlink
|
r110 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r128 | void* args[2] = {NULL, (void*)&arg__1}; | ||
florianlink
|
r110 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r128 | QVariantAnimation::timerEvent(arg__1); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtShell_QVariantAnimation::updateCurrentTime(int arg__1) | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateCurrentTime"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "int"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
florianlink
|
r110 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
florianlink
|
r128 | return; | ||
florianlink
|
r110 | } | ||
} | ||||
florianlink
|
r128 | QVariantAnimation::updateCurrentTime(arg__1); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtShell_QVariantAnimation::updateCurrentValue(const QVariant& value) | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateCurrentValue"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "const QVariant&"}; | ||
florianlink
|
r110 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r128 | void* args[2] = {NULL, (void*)&value}; | ||
florianlink
|
r110 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r128 | |||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtShell_QVariantAnimation::updateDirection(QAbstractAnimation::Direction direction) | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateDirection"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "QAbstractAnimation::Direction"}; | ||
florianlink
|
r110 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r128 | void* args[2] = {NULL, (void*)&direction}; | ||
florianlink
|
r110 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r128 | QVariantAnimation::updateDirection(direction); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtShell_QVariantAnimation::updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState) | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateState"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "QAbstractAnimation::State" , "QAbstractAnimation::State"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
void* args[3] = {NULL, (void*)&newState, (void*)&oldState}; | ||||
florianlink
|
r110 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
florianlink
|
r120 | return; | ||
florianlink
|
r110 | } | ||
} | ||||
florianlink
|
r128 | QVariantAnimation::updateState(newState, oldState); | ||
florianlink
|
r110 | } | ||
QVariantAnimation* PythonQtWrapper_QVariantAnimation::new_QVariantAnimation(QObject* parent) | ||||
{ | ||||
return new PythonQtShell_QVariantAnimation(parent); } | ||||
florianlink
|
r128 | QVariant PythonQtWrapper_QVariantAnimation::currentValue(QVariantAnimation* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->currentValue()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | int PythonQtWrapper_QVariantAnimation::duration(QVariantAnimation* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QVariantAnimation*)theWrappedObject)->promoted_duration()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | QEasingCurve PythonQtWrapper_QVariantAnimation::easingCurve(QVariantAnimation* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->easingCurve()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | QVariant PythonQtWrapper_QVariantAnimation::endValue(QVariantAnimation* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->endValue()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QVariantAnimation::event(QVariantAnimation* theWrappedObject, QEvent* event) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QVariantAnimation*)theWrappedObject)->promoted_event(event)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | QVariant PythonQtWrapper_QVariantAnimation::interpolated(QVariantAnimation* theWrappedObject, const QVariant& from, const QVariant& to, qreal progress) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QVariantAnimation*)theWrappedObject)->promoted_interpolated(from, to, progress)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | QVariant PythonQtWrapper_QVariantAnimation::keyValueAt(QVariantAnimation* theWrappedObject, qreal step) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->keyValueAt(step)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | QVector<QPair<qreal , QVariant > > PythonQtWrapper_QVariantAnimation::keyValues(QVariantAnimation* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->keyValues()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r120 | void PythonQtWrapper_QVariantAnimation::setDuration(QVariantAnimation* theWrappedObject, int msecs) | ||
florianlink
|
r110 | { | ||
florianlink
|
r120 | ( theWrappedObject->setDuration(msecs)); | ||
} | ||||
florianlink
|
r128 | void PythonQtWrapper_QVariantAnimation::setEasingCurve(QVariantAnimation* theWrappedObject, const QEasingCurve& easing) | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | ( theWrappedObject->setEasingCurve(easing)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QVariantAnimation::setEndValue(QVariantAnimation* theWrappedObject, const QVariant& value) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | ( theWrappedObject->setEndValue(value)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QVariantAnimation::setKeyValueAt(QVariantAnimation* theWrappedObject, qreal step, const QVariant& value) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | ( theWrappedObject->setKeyValueAt(step, value)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r120 | void PythonQtWrapper_QVariantAnimation::setKeyValues(QVariantAnimation* theWrappedObject, const QVector<QPair<qreal , QVariant > >& values) | ||
florianlink
|
r110 | { | ||
florianlink
|
r120 | ( theWrappedObject->setKeyValues(values)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QVariantAnimation::setStartValue(QVariantAnimation* theWrappedObject, const QVariant& value) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | ( theWrappedObject->setStartValue(value)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | QVariant PythonQtWrapper_QVariantAnimation::startValue(QVariantAnimation* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->startValue()); | ||
} | ||||
void PythonQtWrapper_QVariantAnimation::updateCurrentTime(QVariantAnimation* theWrappedObject, int arg__1) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QVariantAnimation*)theWrappedObject)->promoted_updateCurrentTime(arg__1)); | ||||
florianlink
|
r110 | } | ||
void PythonQtWrapper_QVariantAnimation::updateState(QVariantAnimation* theWrappedObject, QAbstractAnimation::State newState, QAbstractAnimation::State oldState) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QVariantAnimation*)theWrappedObject)->promoted_updateState(newState, oldState)); | ||||
} | ||||
QWaitCondition* PythonQtWrapper_QWaitCondition::new_QWaitCondition() | ||||
{ | ||||
return new QWaitCondition(); } | ||||
florianlink
|
r128 | bool PythonQtWrapper_QWaitCondition::wait(QWaitCondition* theWrappedObject, QMutex* mutex, unsigned long time) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->wait(mutex, time)); | ||
florianlink
|
r110 | } | ||
bool PythonQtWrapper_QWaitCondition::wait(QWaitCondition* theWrappedObject, QReadWriteLock* readWriteLock, unsigned long time) | ||||
{ | ||||
return ( theWrappedObject->wait(readWriteLock, time)); | ||||
} | ||||
florianlink
|
r128 | void PythonQtWrapper_QWaitCondition::wakeAll(QWaitCondition* theWrappedObject) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | ( theWrappedObject->wakeAll()); | ||
florianlink
|
r110 | } | ||
void PythonQtWrapper_QWaitCondition::wakeOne(QWaitCondition* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->wakeOne()); | ||||
} | ||||
florianlink
|
r186 | PythonQtShell_QXmlStreamEntityResolver::~PythonQtShell_QXmlStreamEntityResolver() { | ||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
florianlink
|
r128 | QString PythonQtShell_QXmlStreamEntityResolver::resolveEntity(const QString& publicId, const QString& systemId) | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resolveEntity"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"QString" , "const QString&" , "const QString&"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
florianlink
|
r110 | QString returnValue; | ||
florianlink
|
r128 | void* args[3] = {NULL, (void*)&publicId, (void*)&systemId}; | ||
florianlink
|
r110 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("resolveEntity", methodInfo, result); | ||
florianlink
|
r110 | } else { | ||
returnValue = *((QString*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QXmlStreamEntityResolver::resolveEntity(publicId, systemId); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | QString PythonQtShell_QXmlStreamEntityResolver::resolveUndeclaredEntity(const QString& name) | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resolveUndeclaredEntity"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"QString" , "const QString&"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
florianlink
|
r110 | QString returnValue; | ||
florianlink
|
r128 | void* args[2] = {NULL, (void*)&name}; | ||
florianlink
|
r110 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("resolveUndeclaredEntity", methodInfo, result); | ||
florianlink
|
r110 | } else { | ||
returnValue = *((QString*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QXmlStreamEntityResolver::resolveUndeclaredEntity(name); | ||
florianlink
|
r110 | } | ||
QXmlStreamEntityResolver* PythonQtWrapper_QXmlStreamEntityResolver::new_QXmlStreamEntityResolver() | ||||
{ | ||||
return new PythonQtShell_QXmlStreamEntityResolver(); } | ||||
florianlink
|
r128 | QString PythonQtWrapper_QXmlStreamEntityResolver::resolveEntity(QXmlStreamEntityResolver* theWrappedObject, const QString& publicId, const QString& systemId) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QXmlStreamEntityResolver*)theWrappedObject)->promoted_resolveEntity(publicId, systemId)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | QString PythonQtWrapper_QXmlStreamEntityResolver::resolveUndeclaredEntity(QXmlStreamEntityResolver* theWrappedObject, const QString& name) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QXmlStreamEntityResolver*)theWrappedObject)->promoted_resolveUndeclaredEntity(name)); | ||
florianlink
|
r110 | } | ||