com_trolltech_qt_network0.cpp
8331 lines
| 298.1 KiB
| text/x-c
|
CppLexer
Orochimarufan
|
r205 | #include "com_trolltech_qt_network0.h" | ||
| #include <PythonQtConversion.h> | ||||
| #include <PythonQtMethodInfo.h> | ||||
| #include <PythonQtSignalReceiver.h> | ||||
| #include <QDateTime> | ||||
| #include <QVariant> | ||||
| #include <qabstractnetworkcache.h> | ||||
| #include <qabstractsocket.h> | ||||
| #include <qauthenticator.h> | ||||
| #include <qbytearray.h> | ||||
| #include <qcoreevent.h> | ||||
| #include <qdatetime.h> | ||||
| #include <qhostaddress.h> | ||||
| #include <qhostinfo.h> | ||||
| #include <qiodevice.h> | ||||
| #include <qlist.h> | ||||
| #include <qlocalserver.h> | ||||
| #include <qlocalsocket.h> | ||||
| #include <qnetworkaccessmanager.h> | ||||
| #include <qnetworkcookie.h> | ||||
| #include <qnetworkcookiejar.h> | ||||
| #include <qnetworkdiskcache.h> | ||||
| #include <qnetworkinterface.h> | ||||
| #include <qnetworkproxy.h> | ||||
| #include <qnetworkreply.h> | ||||
| #include <qnetworkrequest.h> | ||||
| #include <qobject.h> | ||||
| #include <qpair.h> | ||||
| #include <qsslcertificate.h> | ||||
| #include <qsslcipher.h> | ||||
| #include <qsslconfiguration.h> | ||||
| #include <qsslerror.h> | ||||
| #include <qsslkey.h> | ||||
| #include <qsslsocket.h> | ||||
| #include <qstringlist.h> | ||||
| #include <qtcpserver.h> | ||||
| #include <qtcpsocket.h> | ||||
| #include <qudpsocket.h> | ||||
| #include <qurl.h> | ||||
| PythonQtShell_QAbstractNetworkCache::~PythonQtShell_QAbstractNetworkCache() { | ||||
| PythonQtPrivate* priv = PythonQt::priv(); | ||||
| if (priv) { priv->shellClassDeleted(this); } | ||||
| } | ||||
| qint64 PythonQtShell_QAbstractNetworkCache::cacheSize() const | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "cacheSize"); | ||||
| 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("cacheSize", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((qint64*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return qint64(); | ||||
| } | ||||
| void PythonQtShell_QAbstractNetworkCache::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; | ||||
| } | ||||
| } | ||||
| QAbstractNetworkCache::childEvent(arg__1); | ||||
| } | ||||
| void PythonQtShell_QAbstractNetworkCache::clear() | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "clear"); | ||||
| 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; | ||||
| } | ||||
| } | ||||
| } | ||||
| void PythonQtShell_QAbstractNetworkCache::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; | ||||
| } | ||||
| } | ||||
| QAbstractNetworkCache::customEvent(arg__1); | ||||
| } | ||||
| QIODevice* PythonQtShell_QAbstractNetworkCache::data(const QUrl& url) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "data"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"QIODevice*" , "const QUrl&"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| QIODevice* returnValue; | ||||
| void* args[2] = {NULL, (void*)&url}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { | ||||
| args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
| if (args[0]!=&returnValue) { | ||||
| if (args[0]==NULL) { | ||||
| PythonQt::priv()->handleVirtualOverloadReturnError("data", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((QIODevice**)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return 0; | ||||
| } | ||||
| bool PythonQtShell_QAbstractNetworkCache::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 QAbstractNetworkCache::event(arg__1); | ||||
| } | ||||
| bool PythonQtShell_QAbstractNetworkCache::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 QAbstractNetworkCache::eventFilter(arg__1, arg__2); | ||||
| } | ||||
| void PythonQtShell_QAbstractNetworkCache::insert(QIODevice* device) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "insert"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"" , "QIODevice*"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| void* args[2] = {NULL, (void*)&device}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return; | ||||
| } | ||||
| } | ||||
| } | ||||
| QNetworkCacheMetaData PythonQtShell_QAbstractNetworkCache::metaData(const QUrl& url) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metaData"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"QNetworkCacheMetaData" , "const QUrl&"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| QNetworkCacheMetaData returnValue; | ||||
| void* args[2] = {NULL, (void*)&url}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { | ||||
| args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
| if (args[0]!=&returnValue) { | ||||
| if (args[0]==NULL) { | ||||
| PythonQt::priv()->handleVirtualOverloadReturnError("metaData", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((QNetworkCacheMetaData*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QNetworkCacheMetaData(); | ||||
| } | ||||
| QIODevice* PythonQtShell_QAbstractNetworkCache::prepare(const QNetworkCacheMetaData& metaData) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "prepare"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"QIODevice*" , "const QNetworkCacheMetaData&"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| QIODevice* returnValue; | ||||
| void* args[2] = {NULL, (void*)&metaData}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { | ||||
| args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
| if (args[0]!=&returnValue) { | ||||
| if (args[0]==NULL) { | ||||
| PythonQt::priv()->handleVirtualOverloadReturnError("prepare", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((QIODevice**)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return 0; | ||||
| } | ||||
| bool PythonQtShell_QAbstractNetworkCache::remove(const QUrl& url) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "remove"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"bool" , "const QUrl&"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| bool returnValue; | ||||
| void* args[2] = {NULL, (void*)&url}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { | ||||
| args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
| if (args[0]!=&returnValue) { | ||||
| if (args[0]==NULL) { | ||||
| PythonQt::priv()->handleVirtualOverloadReturnError("remove", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((bool*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return bool(); | ||||
| } | ||||
| void PythonQtShell_QAbstractNetworkCache::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; | ||||
| } | ||||
| } | ||||
| QAbstractNetworkCache::timerEvent(arg__1); | ||||
| } | ||||
| void PythonQtShell_QAbstractNetworkCache::updateMetaData(const QNetworkCacheMetaData& metaData) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateMetaData"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"" , "const QNetworkCacheMetaData&"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| void* args[2] = {NULL, (void*)&metaData}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return; | ||||
| } | ||||
| } | ||||
| } | ||||
| PythonQtShell_QAbstractSocket::~PythonQtShell_QAbstractSocket() { | ||||
| PythonQtPrivate* priv = PythonQt::priv(); | ||||
| if (priv) { priv->shellClassDeleted(this); } | ||||
| } | ||||
| bool PythonQtShell_QAbstractSocket::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 QAbstractSocket::atEnd(); | ||||
| } | ||||
| qint64 PythonQtShell_QAbstractSocket::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 QAbstractSocket::bytesAvailable(); | ||||
| } | ||||
| qint64 PythonQtShell_QAbstractSocket::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 QAbstractSocket::bytesToWrite(); | ||||
| } | ||||
| bool PythonQtShell_QAbstractSocket::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 QAbstractSocket::canReadLine(); | ||||
| } | ||||
| void PythonQtShell_QAbstractSocket::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; | ||||
| } | ||||
| } | ||||
| QAbstractSocket::childEvent(arg__1); | ||||
| } | ||||
| void PythonQtShell_QAbstractSocket::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; | ||||
| } | ||||
| } | ||||
| QAbstractSocket::close(); | ||||
| } | ||||
| void PythonQtShell_QAbstractSocket::connectToHost(const QHostAddress& address, unsigned short port, QIODevice::OpenMode mode) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "connectToHost"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"" , "const QHostAddress&" , "unsigned short" , "QIODevice::OpenMode"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
| void* args[4] = {NULL, (void*)&address, (void*)&port, (void*)&mode}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return; | ||||
| } | ||||
| } | ||||
| QAbstractSocket::connectToHost(address, port, mode); | ||||
| } | ||||
| void PythonQtShell_QAbstractSocket::connectToHost(const QString& hostName, unsigned short port, QIODevice::OpenMode mode, QAbstractSocket::NetworkLayerProtocol protocol) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "connectToHost"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"" , "const QString&" , "unsigned short" , "QIODevice::OpenMode" , "QAbstractSocket::NetworkLayerProtocol"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList); | ||||
| void* args[5] = {NULL, (void*)&hostName, (void*)&port, (void*)&mode, (void*)&protocol}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return; | ||||
| } | ||||
| } | ||||
| QAbstractSocket::connectToHost(hostName, port, mode, protocol); | ||||
| } | ||||
| void PythonQtShell_QAbstractSocket::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; | ||||
| } | ||||
| } | ||||
| QAbstractSocket::customEvent(arg__1); | ||||
| } | ||||
| void PythonQtShell_QAbstractSocket::disconnectFromHost() | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "disconnectFromHost"); | ||||
| 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; | ||||
| } | ||||
| } | ||||
| QAbstractSocket::disconnectFromHost(); | ||||
| } | ||||
| bool PythonQtShell_QAbstractSocket::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 QAbstractSocket::event(arg__1); | ||||
| } | ||||
| bool PythonQtShell_QAbstractSocket::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 QAbstractSocket::eventFilter(arg__1, arg__2); | ||||
| } | ||||
| bool PythonQtShell_QAbstractSocket::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 QAbstractSocket::isSequential(); | ||||
| } | ||||
| bool PythonQtShell_QAbstractSocket::open(QIODevice::OpenMode mode) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "open"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"bool" , "QIODevice::OpenMode"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| bool returnValue; | ||||
| void* args[2] = {NULL, (void*)&mode}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { | ||||
| args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
| if (args[0]!=&returnValue) { | ||||
| if (args[0]==NULL) { | ||||
| PythonQt::priv()->handleVirtualOverloadReturnError("open", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((bool*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QAbstractSocket::open(mode); | ||||
| } | ||||
| qint64 PythonQtShell_QAbstractSocket::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 QAbstractSocket::pos(); | ||||
| } | ||||
| qint64 PythonQtShell_QAbstractSocket::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 QAbstractSocket::readData(data, maxlen); | ||||
| } | ||||
| qint64 PythonQtShell_QAbstractSocket::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 QAbstractSocket::readLineData(data, maxlen); | ||||
| } | ||||
| bool PythonQtShell_QAbstractSocket::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 QAbstractSocket::reset(); | ||||
| } | ||||
| void PythonQtShell_QAbstractSocket::resume() | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resume"); | ||||
| 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; | ||||
| } | ||||
| } | ||||
| QAbstractSocket::resume(); | ||||
| } | ||||
| bool PythonQtShell_QAbstractSocket::seek(qint64 pos) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "seek"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"bool" , "qint64"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| bool returnValue; | ||||
| void* args[2] = {NULL, (void*)&pos}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { | ||||
| args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
| if (args[0]!=&returnValue) { | ||||
| if (args[0]==NULL) { | ||||
| PythonQt::priv()->handleVirtualOverloadReturnError("seek", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((bool*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QAbstractSocket::seek(pos); | ||||
| } | ||||
| void PythonQtShell_QAbstractSocket::setReadBufferSize(qint64 size) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setReadBufferSize"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"" , "qint64"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| void* args[2] = {NULL, (void*)&size}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return; | ||||
| } | ||||
| } | ||||
| QAbstractSocket::setReadBufferSize(size); | ||||
| } | ||||
| void PythonQtShell_QAbstractSocket::setSocketOption(QAbstractSocket::SocketOption option, const QVariant& value) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setSocketOption"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"" , "QAbstractSocket::SocketOption" , "const QVariant&"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
| void* args[3] = {NULL, (void*)&option, (void*)&value}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return; | ||||
| } | ||||
| } | ||||
| QAbstractSocket::setSocketOption(option, value); | ||||
| } | ||||
| qint64 PythonQtShell_QAbstractSocket::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 QAbstractSocket::size(); | ||||
| } | ||||
| QVariant PythonQtShell_QAbstractSocket::socketOption(QAbstractSocket::SocketOption option) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "socketOption"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"QVariant" , "QAbstractSocket::SocketOption"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| QVariant returnValue; | ||||
| void* args[2] = {NULL, (void*)&option}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { | ||||
| args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
| if (args[0]!=&returnValue) { | ||||
| if (args[0]==NULL) { | ||||
| PythonQt::priv()->handleVirtualOverloadReturnError("socketOption", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((QVariant*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QAbstractSocket::socketOption(option); | ||||
| } | ||||
| void PythonQtShell_QAbstractSocket::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; | ||||
| } | ||||
| } | ||||
| QAbstractSocket::timerEvent(arg__1); | ||||
| } | ||||
| bool PythonQtShell_QAbstractSocket::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 QAbstractSocket::waitForBytesWritten(msecs); | ||||
| } | ||||
| bool PythonQtShell_QAbstractSocket::waitForConnected(int msecs) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "waitForConnected"); | ||||
| 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("waitForConnected", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((bool*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QAbstractSocket::waitForConnected(msecs); | ||||
| } | ||||
| bool PythonQtShell_QAbstractSocket::waitForDisconnected(int msecs) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "waitForDisconnected"); | ||||
| 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("waitForDisconnected", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((bool*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QAbstractSocket::waitForDisconnected(msecs); | ||||
| } | ||||
| bool PythonQtShell_QAbstractSocket::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 QAbstractSocket::waitForReadyRead(msecs); | ||||
| } | ||||
| qint64 PythonQtShell_QAbstractSocket::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 QAbstractSocket::writeData(data, len); | ||||
| } | ||||
| QAbstractSocket* PythonQtWrapper_QAbstractSocket::new_QAbstractSocket(QAbstractSocket::SocketType socketType, QObject* parent) | ||||
| { | ||||
| return new PythonQtShell_QAbstractSocket(socketType, parent); } | ||||
| void PythonQtWrapper_QAbstractSocket::abort(QAbstractSocket* theWrappedObject) | ||||
| { | ||||
| ( theWrappedObject->abort()); | ||||
| } | ||||
| bool PythonQtWrapper_QAbstractSocket::atEnd(QAbstractSocket* theWrappedObject) const | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_atEnd()); | ||||
| } | ||||
| qint64 PythonQtWrapper_QAbstractSocket::bytesAvailable(QAbstractSocket* theWrappedObject) const | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_bytesAvailable()); | ||||
| } | ||||
| qint64 PythonQtWrapper_QAbstractSocket::bytesToWrite(QAbstractSocket* theWrappedObject) const | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_bytesToWrite()); | ||||
| } | ||||
| bool PythonQtWrapper_QAbstractSocket::canReadLine(QAbstractSocket* theWrappedObject) const | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_canReadLine()); | ||||
| } | ||||
| void PythonQtWrapper_QAbstractSocket::close(QAbstractSocket* theWrappedObject) | ||||
| { | ||||
| ( ((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_close()); | ||||
| } | ||||
| void PythonQtWrapper_QAbstractSocket::connectToHost(QAbstractSocket* theWrappedObject, const QHostAddress& address, unsigned short port, QIODevice::OpenMode mode) | ||||
| { | ||||
| ( ((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_connectToHost(address, port, mode)); | ||||
| } | ||||
| void PythonQtWrapper_QAbstractSocket::connectToHost(QAbstractSocket* theWrappedObject, const QString& hostName, unsigned short port, QIODevice::OpenMode mode, QAbstractSocket::NetworkLayerProtocol protocol) | ||||
| { | ||||
| ( ((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_connectToHost(hostName, port, mode, protocol)); | ||||
| } | ||||
| void PythonQtWrapper_QAbstractSocket::disconnectFromHost(QAbstractSocket* theWrappedObject) | ||||
| { | ||||
| ( ((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_disconnectFromHost()); | ||||
| } | ||||
| QAbstractSocket::SocketError PythonQtWrapper_QAbstractSocket::error(QAbstractSocket* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->error()); | ||||
| } | ||||
| bool PythonQtWrapper_QAbstractSocket::flush(QAbstractSocket* theWrappedObject) | ||||
| { | ||||
| return ( theWrappedObject->flush()); | ||||
| } | ||||
| bool PythonQtWrapper_QAbstractSocket::isSequential(QAbstractSocket* theWrappedObject) const | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_isSequential()); | ||||
| } | ||||
| bool PythonQtWrapper_QAbstractSocket::isValid(QAbstractSocket* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->isValid()); | ||||
| } | ||||
| QHostAddress PythonQtWrapper_QAbstractSocket::localAddress(QAbstractSocket* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->localAddress()); | ||||
| } | ||||
| unsigned short PythonQtWrapper_QAbstractSocket::localPort(QAbstractSocket* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->localPort()); | ||||
| } | ||||
| QHostAddress PythonQtWrapper_QAbstractSocket::peerAddress(QAbstractSocket* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->peerAddress()); | ||||
| } | ||||
| QString PythonQtWrapper_QAbstractSocket::peerName(QAbstractSocket* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->peerName()); | ||||
| } | ||||
| unsigned short PythonQtWrapper_QAbstractSocket::peerPort(QAbstractSocket* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->peerPort()); | ||||
| } | ||||
| QNetworkProxy PythonQtWrapper_QAbstractSocket::proxy(QAbstractSocket* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->proxy()); | ||||
| } | ||||
| qint64 PythonQtWrapper_QAbstractSocket::readBufferSize(QAbstractSocket* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->readBufferSize()); | ||||
| } | ||||
| qint64 PythonQtWrapper_QAbstractSocket::readData(QAbstractSocket* theWrappedObject, char* data, qint64 maxlen) | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_readData(data, maxlen)); | ||||
| } | ||||
| qint64 PythonQtWrapper_QAbstractSocket::readLineData(QAbstractSocket* theWrappedObject, char* data, qint64 maxlen) | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_readLineData(data, maxlen)); | ||||
| } | ||||
| void PythonQtWrapper_QAbstractSocket::resume(QAbstractSocket* theWrappedObject) | ||||
| { | ||||
| ( ((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_resume()); | ||||
| } | ||||
| void PythonQtWrapper_QAbstractSocket::setProxy(QAbstractSocket* theWrappedObject, const QNetworkProxy& networkProxy) | ||||
| { | ||||
| ( theWrappedObject->setProxy(networkProxy)); | ||||
| } | ||||
| void PythonQtWrapper_QAbstractSocket::setReadBufferSize(QAbstractSocket* theWrappedObject, qint64 size) | ||||
| { | ||||
| ( ((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_setReadBufferSize(size)); | ||||
| } | ||||
| void PythonQtWrapper_QAbstractSocket::setSocketOption(QAbstractSocket* theWrappedObject, QAbstractSocket::SocketOption option, const QVariant& value) | ||||
| { | ||||
| ( ((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_setSocketOption(option, value)); | ||||
| } | ||||
| QVariant PythonQtWrapper_QAbstractSocket::socketOption(QAbstractSocket* theWrappedObject, QAbstractSocket::SocketOption option) | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_socketOption(option)); | ||||
| } | ||||
| QAbstractSocket::SocketType PythonQtWrapper_QAbstractSocket::socketType(QAbstractSocket* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->socketType()); | ||||
| } | ||||
| QAbstractSocket::SocketState PythonQtWrapper_QAbstractSocket::state(QAbstractSocket* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->state()); | ||||
| } | ||||
| bool PythonQtWrapper_QAbstractSocket::waitForBytesWritten(QAbstractSocket* theWrappedObject, int msecs) | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_waitForBytesWritten(msecs)); | ||||
| } | ||||
| bool PythonQtWrapper_QAbstractSocket::waitForConnected(QAbstractSocket* theWrappedObject, int msecs) | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_waitForConnected(msecs)); | ||||
| } | ||||
| bool PythonQtWrapper_QAbstractSocket::waitForDisconnected(QAbstractSocket* theWrappedObject, int msecs) | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_waitForDisconnected(msecs)); | ||||
| } | ||||
| bool PythonQtWrapper_QAbstractSocket::waitForReadyRead(QAbstractSocket* theWrappedObject, int msecs) | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_waitForReadyRead(msecs)); | ||||
| } | ||||
| qint64 PythonQtWrapper_QAbstractSocket::writeData(QAbstractSocket* theWrappedObject, const char* data, qint64 len) | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_writeData(data, len)); | ||||
| } | ||||
| QAuthenticator* PythonQtWrapper_QAuthenticator::new_QAuthenticator() | ||||
| { | ||||
| return new QAuthenticator(); } | ||||
| QAuthenticator* PythonQtWrapper_QAuthenticator::new_QAuthenticator(const QAuthenticator& other) | ||||
| { | ||||
| return new QAuthenticator(other); } | ||||
| bool PythonQtWrapper_QAuthenticator::isNull(QAuthenticator* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->isNull()); | ||||
| } | ||||
| bool PythonQtWrapper_QAuthenticator::__ne__(QAuthenticator* theWrappedObject, const QAuthenticator& other) const | ||||
| { | ||||
| return ( (*theWrappedObject)!= other); | ||||
| } | ||||
| bool PythonQtWrapper_QAuthenticator::__eq__(QAuthenticator* theWrappedObject, const QAuthenticator& other) const | ||||
| { | ||||
| return ( (*theWrappedObject)== other); | ||||
| } | ||||
| QVariant PythonQtWrapper_QAuthenticator::option(QAuthenticator* theWrappedObject, const QString& opt) const | ||||
| { | ||||
| return ( theWrappedObject->option(opt)); | ||||
| } | ||||
| QHash<QString , QVariant > PythonQtWrapper_QAuthenticator::options(QAuthenticator* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->options()); | ||||
| } | ||||
| QString PythonQtWrapper_QAuthenticator::password(QAuthenticator* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->password()); | ||||
| } | ||||
| QString PythonQtWrapper_QAuthenticator::realm(QAuthenticator* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->realm()); | ||||
| } | ||||
| void PythonQtWrapper_QAuthenticator::setOption(QAuthenticator* theWrappedObject, const QString& opt, const QVariant& value) | ||||
| { | ||||
| ( theWrappedObject->setOption(opt, value)); | ||||
| } | ||||
| void PythonQtWrapper_QAuthenticator::setPassword(QAuthenticator* theWrappedObject, const QString& password) | ||||
| { | ||||
| ( theWrappedObject->setPassword(password)); | ||||
| } | ||||
| void PythonQtWrapper_QAuthenticator::setUser(QAuthenticator* theWrappedObject, const QString& user) | ||||
| { | ||||
| ( theWrappedObject->setUser(user)); | ||||
| } | ||||
| QString PythonQtWrapper_QAuthenticator::user(QAuthenticator* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->user()); | ||||
| } | ||||
| QHostAddress* PythonQtWrapper_QHostAddress::new_QHostAddress() | ||||
| { | ||||
| return new QHostAddress(); } | ||||
| QHostAddress* PythonQtWrapper_QHostAddress::new_QHostAddress(QHostAddress::SpecialAddress address) | ||||
| { | ||||
| return new QHostAddress(address); } | ||||
| QHostAddress* PythonQtWrapper_QHostAddress::new_QHostAddress(const QHostAddress& copy) | ||||
| { | ||||
| return new QHostAddress(copy); } | ||||
| QHostAddress* PythonQtWrapper_QHostAddress::new_QHostAddress(const QIPv6Address& ip6Addr) | ||||
| { | ||||
| return new QHostAddress(ip6Addr); } | ||||
| QHostAddress* PythonQtWrapper_QHostAddress::new_QHostAddress(const QString& address) | ||||
| { | ||||
| return new QHostAddress(address); } | ||||
| QHostAddress* PythonQtWrapper_QHostAddress::new_QHostAddress(unsigned int ip4Addr) | ||||
| { | ||||
| return new QHostAddress(ip4Addr); } | ||||
| void PythonQtWrapper_QHostAddress::clear(QHostAddress* theWrappedObject) | ||||
| { | ||||
| ( theWrappedObject->clear()); | ||||
| } | ||||
| bool PythonQtWrapper_QHostAddress::isInSubnet(QHostAddress* theWrappedObject, const QHostAddress& subnet, int netmask) const | ||||
| { | ||||
| return ( theWrappedObject->isInSubnet(subnet, netmask)); | ||||
| } | ||||
| bool PythonQtWrapper_QHostAddress::isInSubnet(QHostAddress* theWrappedObject, const QPair<QHostAddress , int >& subnet) const | ||||
| { | ||||
| return ( theWrappedObject->isInSubnet(subnet)); | ||||
| } | ||||
| bool PythonQtWrapper_QHostAddress::isLoopback(QHostAddress* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->isLoopback()); | ||||
| } | ||||
| bool PythonQtWrapper_QHostAddress::isNull(QHostAddress* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->isNull()); | ||||
| } | ||||
| bool PythonQtWrapper_QHostAddress::__ne__(QHostAddress* theWrappedObject, QHostAddress::SpecialAddress address) const | ||||
| { | ||||
| return ( (*theWrappedObject)!= address); | ||||
| } | ||||
| bool PythonQtWrapper_QHostAddress::__ne__(QHostAddress* theWrappedObject, const QHostAddress& address) const | ||||
| { | ||||
| return ( (*theWrappedObject)!= address); | ||||
| } | ||||
| bool PythonQtWrapper_QHostAddress::__eq__(QHostAddress* theWrappedObject, QHostAddress::SpecialAddress address) const | ||||
| { | ||||
| return ( (*theWrappedObject)== address); | ||||
| } | ||||
| bool PythonQtWrapper_QHostAddress::__eq__(QHostAddress* theWrappedObject, const QHostAddress& address) const | ||||
| { | ||||
| return ( (*theWrappedObject)== address); | ||||
| } | ||||
| QPair<QHostAddress , int > PythonQtWrapper_QHostAddress::static_QHostAddress_parseSubnet(const QString& subnet) | ||||
| { | ||||
| return (QHostAddress::parseSubnet(subnet)); | ||||
| } | ||||
| QAbstractSocket::NetworkLayerProtocol PythonQtWrapper_QHostAddress::protocol(QHostAddress* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->protocol()); | ||||
| } | ||||
| QString PythonQtWrapper_QHostAddress::scopeId(QHostAddress* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->scopeId()); | ||||
| } | ||||
| void PythonQtWrapper_QHostAddress::setAddress(QHostAddress* theWrappedObject, const QIPv6Address& ip6Addr) | ||||
| { | ||||
| ( theWrappedObject->setAddress(ip6Addr)); | ||||
| } | ||||
| bool PythonQtWrapper_QHostAddress::setAddress(QHostAddress* theWrappedObject, const QString& address) | ||||
| { | ||||
| return ( theWrappedObject->setAddress(address)); | ||||
| } | ||||
| void PythonQtWrapper_QHostAddress::setAddress(QHostAddress* theWrappedObject, unsigned int ip4Addr) | ||||
| { | ||||
| ( theWrappedObject->setAddress(ip4Addr)); | ||||
| } | ||||
| void PythonQtWrapper_QHostAddress::setScopeId(QHostAddress* theWrappedObject, const QString& id) | ||||
| { | ||||
| ( theWrappedObject->setScopeId(id)); | ||||
| } | ||||
| unsigned int PythonQtWrapper_QHostAddress::toIPv4Address(QHostAddress* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->toIPv4Address()); | ||||
| } | ||||
| QIPv6Address PythonQtWrapper_QHostAddress::toIPv6Address(QHostAddress* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->toIPv6Address()); | ||||
| } | ||||
| QString PythonQtWrapper_QHostAddress::toString(QHostAddress* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->toString()); | ||||
| } | ||||
| QString PythonQtWrapper_QHostAddress::py_toString(QHostAddress* obj) { return obj->toString(); } | ||||
| QHostInfo* PythonQtWrapper_QHostInfo::new_QHostInfo(const QHostInfo& d) | ||||
| { | ||||
| return new QHostInfo(d); } | ||||
| QHostInfo* PythonQtWrapper_QHostInfo::new_QHostInfo(int lookupId) | ||||
| { | ||||
| return new QHostInfo(lookupId); } | ||||
| void PythonQtWrapper_QHostInfo::static_QHostInfo_abortHostLookup(int lookupId) | ||||
| { | ||||
| (QHostInfo::abortHostLookup(lookupId)); | ||||
| } | ||||
| QList<QHostAddress > PythonQtWrapper_QHostInfo::addresses(QHostInfo* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->addresses()); | ||||
| } | ||||
| QHostInfo::HostInfoError PythonQtWrapper_QHostInfo::error(QHostInfo* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->error()); | ||||
| } | ||||
| QString PythonQtWrapper_QHostInfo::errorString(QHostInfo* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->errorString()); | ||||
| } | ||||
| QHostInfo PythonQtWrapper_QHostInfo::static_QHostInfo_fromName(const QString& name) | ||||
| { | ||||
| return (QHostInfo::fromName(name)); | ||||
| } | ||||
| QString PythonQtWrapper_QHostInfo::hostName(QHostInfo* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->hostName()); | ||||
| } | ||||
| QString PythonQtWrapper_QHostInfo::static_QHostInfo_localDomainName() | ||||
| { | ||||
| return (QHostInfo::localDomainName()); | ||||
| } | ||||
| QString PythonQtWrapper_QHostInfo::static_QHostInfo_localHostName() | ||||
| { | ||||
| return (QHostInfo::localHostName()); | ||||
| } | ||||
| int PythonQtWrapper_QHostInfo::static_QHostInfo_lookupHost(const QString& name, QObject* receiver, const char* member) | ||||
| { | ||||
| return (QHostInfo::lookupHost(name, receiver, member)); | ||||
| } | ||||
| int PythonQtWrapper_QHostInfo::lookupId(QHostInfo* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->lookupId()); | ||||
| } | ||||
| void PythonQtWrapper_QHostInfo::setAddresses(QHostInfo* theWrappedObject, const QList<QHostAddress >& addresses) | ||||
| { | ||||
| ( theWrappedObject->setAddresses(addresses)); | ||||
| } | ||||
| void PythonQtWrapper_QHostInfo::setError(QHostInfo* theWrappedObject, QHostInfo::HostInfoError error) | ||||
| { | ||||
| ( theWrappedObject->setError(error)); | ||||
| } | ||||
| void PythonQtWrapper_QHostInfo::setErrorString(QHostInfo* theWrappedObject, const QString& errorString) | ||||
| { | ||||
| ( theWrappedObject->setErrorString(errorString)); | ||||
| } | ||||
| void PythonQtWrapper_QHostInfo::setHostName(QHostInfo* theWrappedObject, const QString& name) | ||||
| { | ||||
| ( theWrappedObject->setHostName(name)); | ||||
| } | ||||
| void PythonQtWrapper_QHostInfo::setLookupId(QHostInfo* theWrappedObject, int id) | ||||
| { | ||||
| ( theWrappedObject->setLookupId(id)); | ||||
| } | ||||
| PythonQtShell_QIPv6Address::~PythonQtShell_QIPv6Address() { | ||||
| PythonQtPrivate* priv = PythonQt::priv(); | ||||
| if (priv) { priv->shellClassDeleted(this); } | ||||
| } | ||||
| QIPv6Address* PythonQtWrapper_QIPv6Address::new_QIPv6Address() | ||||
| { | ||||
| return new PythonQtShell_QIPv6Address(); } | ||||
| PythonQtShell_QLocalServer::~PythonQtShell_QLocalServer() { | ||||
| PythonQtPrivate* priv = PythonQt::priv(); | ||||
| if (priv) { priv->shellClassDeleted(this); } | ||||
| } | ||||
| void PythonQtShell_QLocalServer::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; | ||||
| } | ||||
| } | ||||
| QLocalServer::childEvent(arg__1); | ||||
| } | ||||
| void PythonQtShell_QLocalServer::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; | ||||
| } | ||||
| } | ||||
| QLocalServer::customEvent(arg__1); | ||||
| } | ||||
| bool PythonQtShell_QLocalServer::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 QLocalServer::event(arg__1); | ||||
| } | ||||
| bool PythonQtShell_QLocalServer::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 QLocalServer::eventFilter(arg__1, arg__2); | ||||
| } | ||||
| bool PythonQtShell_QLocalServer::hasPendingConnections() const | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasPendingConnections"); | ||||
| 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("hasPendingConnections", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((bool*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QLocalServer::hasPendingConnections(); | ||||
| } | ||||
| void PythonQtShell_QLocalServer::incomingConnection(quintptr socketDescriptor) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "incomingConnection"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"" , "quintptr"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| void* args[2] = {NULL, (void*)&socketDescriptor}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return; | ||||
| } | ||||
| } | ||||
| QLocalServer::incomingConnection(socketDescriptor); | ||||
| } | ||||
| QLocalSocket* PythonQtShell_QLocalServer::nextPendingConnection() | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nextPendingConnection"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"QLocalSocket*"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
| QLocalSocket* 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("nextPendingConnection", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((QLocalSocket**)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QLocalServer::nextPendingConnection(); | ||||
| } | ||||
| void PythonQtShell_QLocalServer::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; | ||||
| } | ||||
| } | ||||
| QLocalServer::timerEvent(arg__1); | ||||
| } | ||||
| QLocalServer* PythonQtWrapper_QLocalServer::new_QLocalServer(QObject* parent) | ||||
| { | ||||
| return new PythonQtShell_QLocalServer(parent); } | ||||
| void PythonQtWrapper_QLocalServer::close(QLocalServer* theWrappedObject) | ||||
| { | ||||
| ( theWrappedObject->close()); | ||||
| } | ||||
| QString PythonQtWrapper_QLocalServer::errorString(QLocalServer* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->errorString()); | ||||
| } | ||||
| QString PythonQtWrapper_QLocalServer::fullServerName(QLocalServer* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->fullServerName()); | ||||
| } | ||||
| bool PythonQtWrapper_QLocalServer::hasPendingConnections(QLocalServer* theWrappedObject) const | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QLocalServer*)theWrappedObject)->promoted_hasPendingConnections()); | ||||
| } | ||||
| void PythonQtWrapper_QLocalServer::incomingConnection(QLocalServer* theWrappedObject, quintptr socketDescriptor) | ||||
| { | ||||
| ( ((PythonQtPublicPromoter_QLocalServer*)theWrappedObject)->promoted_incomingConnection(socketDescriptor)); | ||||
| } | ||||
| bool PythonQtWrapper_QLocalServer::isListening(QLocalServer* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->isListening()); | ||||
| } | ||||
| bool PythonQtWrapper_QLocalServer::listen(QLocalServer* theWrappedObject, const QString& name) | ||||
| { | ||||
| return ( theWrappedObject->listen(name)); | ||||
| } | ||||
| int PythonQtWrapper_QLocalServer::maxPendingConnections(QLocalServer* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->maxPendingConnections()); | ||||
| } | ||||
| QLocalSocket* PythonQtWrapper_QLocalServer::nextPendingConnection(QLocalServer* theWrappedObject) | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QLocalServer*)theWrappedObject)->promoted_nextPendingConnection()); | ||||
| } | ||||
| bool PythonQtWrapper_QLocalServer::static_QLocalServer_removeServer(const QString& name) | ||||
| { | ||||
| return (QLocalServer::removeServer(name)); | ||||
| } | ||||
| QAbstractSocket::SocketError PythonQtWrapper_QLocalServer::serverError(QLocalServer* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->serverError()); | ||||
| } | ||||
| QString PythonQtWrapper_QLocalServer::serverName(QLocalServer* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->serverName()); | ||||
| } | ||||
| void PythonQtWrapper_QLocalServer::setMaxPendingConnections(QLocalServer* theWrappedObject, int numConnections) | ||||
| { | ||||
| ( theWrappedObject->setMaxPendingConnections(numConnections)); | ||||
| } | ||||
| bool PythonQtWrapper_QLocalServer::waitForNewConnection(QLocalServer* theWrappedObject, int msec, bool* timedOut) | ||||
| { | ||||
| return ( theWrappedObject->waitForNewConnection(msec, timedOut)); | ||||
| } | ||||
| PythonQtShell_QLocalSocket::~PythonQtShell_QLocalSocket() { | ||||
| PythonQtPrivate* priv = PythonQt::priv(); | ||||
| if (priv) { priv->shellClassDeleted(this); } | ||||
| } | ||||
| bool PythonQtShell_QLocalSocket::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 QLocalSocket::atEnd(); | ||||
| } | ||||
| qint64 PythonQtShell_QLocalSocket::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 QLocalSocket::bytesAvailable(); | ||||
| } | ||||
| qint64 PythonQtShell_QLocalSocket::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 QLocalSocket::bytesToWrite(); | ||||
| } | ||||
| bool PythonQtShell_QLocalSocket::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 QLocalSocket::canReadLine(); | ||||
| } | ||||
| void PythonQtShell_QLocalSocket::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; | ||||
| } | ||||
| } | ||||
| QLocalSocket::childEvent(arg__1); | ||||
| } | ||||
| void PythonQtShell_QLocalSocket::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; | ||||
| } | ||||
| } | ||||
| QLocalSocket::close(); | ||||
| } | ||||
| void PythonQtShell_QLocalSocket::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; | ||||
| } | ||||
| } | ||||
| QLocalSocket::customEvent(arg__1); | ||||
| } | ||||
| bool PythonQtShell_QLocalSocket::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 QLocalSocket::event(arg__1); | ||||
| } | ||||
| bool PythonQtShell_QLocalSocket::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 QLocalSocket::eventFilter(arg__1, arg__2); | ||||
| } | ||||
| bool PythonQtShell_QLocalSocket::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 QLocalSocket::isSequential(); | ||||
| } | ||||
| bool PythonQtShell_QLocalSocket::open(QIODevice::OpenMode mode) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "open"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"bool" , "QIODevice::OpenMode"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| bool returnValue; | ||||
| void* args[2] = {NULL, (void*)&mode}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { | ||||
| args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
| if (args[0]!=&returnValue) { | ||||
| if (args[0]==NULL) { | ||||
| PythonQt::priv()->handleVirtualOverloadReturnError("open", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((bool*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QLocalSocket::open(mode); | ||||
| } | ||||
| qint64 PythonQtShell_QLocalSocket::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 QLocalSocket::pos(); | ||||
| } | ||||
| qint64 PythonQtShell_QLocalSocket::readData(char* arg__1, qint64 arg__2) | ||||
| { | ||||
| 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*)&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("readData", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((qint64*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QLocalSocket::readData(arg__1, arg__2); | ||||
| } | ||||
| qint64 PythonQtShell_QLocalSocket::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 QLocalSocket::readLineData(data, maxlen); | ||||
| } | ||||
| bool PythonQtShell_QLocalSocket::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 QLocalSocket::reset(); | ||||
| } | ||||
| bool PythonQtShell_QLocalSocket::seek(qint64 pos) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "seek"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"bool" , "qint64"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| bool returnValue; | ||||
| void* args[2] = {NULL, (void*)&pos}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { | ||||
| args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
| if (args[0]!=&returnValue) { | ||||
| if (args[0]==NULL) { | ||||
| PythonQt::priv()->handleVirtualOverloadReturnError("seek", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((bool*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QLocalSocket::seek(pos); | ||||
| } | ||||
| qint64 PythonQtShell_QLocalSocket::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 QLocalSocket::size(); | ||||
| } | ||||
| void PythonQtShell_QLocalSocket::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; | ||||
| } | ||||
| } | ||||
| QLocalSocket::timerEvent(arg__1); | ||||
| } | ||||
| bool PythonQtShell_QLocalSocket::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 QLocalSocket::waitForBytesWritten(msecs); | ||||
| } | ||||
| bool PythonQtShell_QLocalSocket::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 QLocalSocket::waitForReadyRead(msecs); | ||||
| } | ||||
| qint64 PythonQtShell_QLocalSocket::writeData(const char* arg__1, qint64 arg__2) | ||||
| { | ||||
| 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*)&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("writeData", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((qint64*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QLocalSocket::writeData(arg__1, arg__2); | ||||
| } | ||||
| QLocalSocket* PythonQtWrapper_QLocalSocket::new_QLocalSocket(QObject* parent) | ||||
| { | ||||
| return new PythonQtShell_QLocalSocket(parent); } | ||||
| void PythonQtWrapper_QLocalSocket::abort(QLocalSocket* theWrappedObject) | ||||
| { | ||||
| ( theWrappedObject->abort()); | ||||
| } | ||||
| qint64 PythonQtWrapper_QLocalSocket::bytesAvailable(QLocalSocket* theWrappedObject) const | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QLocalSocket*)theWrappedObject)->promoted_bytesAvailable()); | ||||
| } | ||||
| qint64 PythonQtWrapper_QLocalSocket::bytesToWrite(QLocalSocket* theWrappedObject) const | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QLocalSocket*)theWrappedObject)->promoted_bytesToWrite()); | ||||
| } | ||||
| bool PythonQtWrapper_QLocalSocket::canReadLine(QLocalSocket* theWrappedObject) const | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QLocalSocket*)theWrappedObject)->promoted_canReadLine()); | ||||
| } | ||||
| void PythonQtWrapper_QLocalSocket::close(QLocalSocket* theWrappedObject) | ||||
| { | ||||
| ( ((PythonQtPublicPromoter_QLocalSocket*)theWrappedObject)->promoted_close()); | ||||
| } | ||||
| void PythonQtWrapper_QLocalSocket::connectToServer(QLocalSocket* theWrappedObject, const QString& name, QIODevice::OpenMode openMode) | ||||
| { | ||||
| ( theWrappedObject->connectToServer(name, openMode)); | ||||
| } | ||||
| void PythonQtWrapper_QLocalSocket::disconnectFromServer(QLocalSocket* theWrappedObject) | ||||
| { | ||||
| ( theWrappedObject->disconnectFromServer()); | ||||
| } | ||||
| QLocalSocket::LocalSocketError PythonQtWrapper_QLocalSocket::error(QLocalSocket* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->error()); | ||||
| } | ||||
| bool PythonQtWrapper_QLocalSocket::flush(QLocalSocket* theWrappedObject) | ||||
| { | ||||
| return ( theWrappedObject->flush()); | ||||
| } | ||||
| QString PythonQtWrapper_QLocalSocket::fullServerName(QLocalSocket* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->fullServerName()); | ||||
| } | ||||
| bool PythonQtWrapper_QLocalSocket::isSequential(QLocalSocket* theWrappedObject) const | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QLocalSocket*)theWrappedObject)->promoted_isSequential()); | ||||
| } | ||||
| bool PythonQtWrapper_QLocalSocket::isValid(QLocalSocket* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->isValid()); | ||||
| } | ||||
| qint64 PythonQtWrapper_QLocalSocket::readBufferSize(QLocalSocket* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->readBufferSize()); | ||||
| } | ||||
| qint64 PythonQtWrapper_QLocalSocket::readData(QLocalSocket* theWrappedObject, char* arg__1, qint64 arg__2) | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QLocalSocket*)theWrappedObject)->promoted_readData(arg__1, arg__2)); | ||||
| } | ||||
| QString PythonQtWrapper_QLocalSocket::serverName(QLocalSocket* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->serverName()); | ||||
| } | ||||
| void PythonQtWrapper_QLocalSocket::setReadBufferSize(QLocalSocket* theWrappedObject, qint64 size) | ||||
| { | ||||
| ( theWrappedObject->setReadBufferSize(size)); | ||||
| } | ||||
| QLocalSocket::LocalSocketState PythonQtWrapper_QLocalSocket::state(QLocalSocket* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->state()); | ||||
| } | ||||
| bool PythonQtWrapper_QLocalSocket::waitForBytesWritten(QLocalSocket* theWrappedObject, int msecs) | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QLocalSocket*)theWrappedObject)->promoted_waitForBytesWritten(msecs)); | ||||
| } | ||||
| bool PythonQtWrapper_QLocalSocket::waitForConnected(QLocalSocket* theWrappedObject, int msecs) | ||||
| { | ||||
| return ( theWrappedObject->waitForConnected(msecs)); | ||||
| } | ||||
| bool PythonQtWrapper_QLocalSocket::waitForDisconnected(QLocalSocket* theWrappedObject, int msecs) | ||||
| { | ||||
| return ( theWrappedObject->waitForDisconnected(msecs)); | ||||
| } | ||||
| bool PythonQtWrapper_QLocalSocket::waitForReadyRead(QLocalSocket* theWrappedObject, int msecs) | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QLocalSocket*)theWrappedObject)->promoted_waitForReadyRead(msecs)); | ||||
| } | ||||
| qint64 PythonQtWrapper_QLocalSocket::writeData(QLocalSocket* theWrappedObject, const char* arg__1, qint64 arg__2) | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QLocalSocket*)theWrappedObject)->promoted_writeData(arg__1, arg__2)); | ||||
| } | ||||
| PythonQtShell_QNetworkAccessManager::~PythonQtShell_QNetworkAccessManager() { | ||||
| PythonQtPrivate* priv = PythonQt::priv(); | ||||
| if (priv) { priv->shellClassDeleted(this); } | ||||
| } | ||||
| void PythonQtShell_QNetworkAccessManager::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; | ||||
| } | ||||
| } | ||||
| QNetworkAccessManager::childEvent(arg__1); | ||||
| } | ||||
| QNetworkReply* PythonQtShell_QNetworkAccessManager::createRequest(QNetworkAccessManager::Operation op, const QNetworkRequest& request, QIODevice* outgoingData) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "createRequest"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"QNetworkReply*" , "QNetworkAccessManager::Operation" , "const QNetworkRequest&" , "QIODevice*"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
| QNetworkReply* returnValue; | ||||
| void* args[4] = {NULL, (void*)&op, (void*)&request, (void*)&outgoingData}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { | ||||
| args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
| if (args[0]!=&returnValue) { | ||||
| if (args[0]==NULL) { | ||||
| PythonQt::priv()->handleVirtualOverloadReturnError("createRequest", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((QNetworkReply**)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QNetworkAccessManager::createRequest(op, request, outgoingData); | ||||
| } | ||||
| void PythonQtShell_QNetworkAccessManager::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; | ||||
| } | ||||
| } | ||||
| QNetworkAccessManager::customEvent(arg__1); | ||||
| } | ||||
| bool PythonQtShell_QNetworkAccessManager::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 QNetworkAccessManager::event(arg__1); | ||||
| } | ||||
| bool PythonQtShell_QNetworkAccessManager::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 QNetworkAccessManager::eventFilter(arg__1, arg__2); | ||||
| } | ||||
| void PythonQtShell_QNetworkAccessManager::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; | ||||
| } | ||||
| } | ||||
| QNetworkAccessManager::timerEvent(arg__1); | ||||
| } | ||||
| QNetworkAccessManager* PythonQtWrapper_QNetworkAccessManager::new_QNetworkAccessManager(QObject* parent) | ||||
| { | ||||
| return new PythonQtShell_QNetworkAccessManager(parent); } | ||||
| QAbstractNetworkCache* PythonQtWrapper_QNetworkAccessManager::cache(QNetworkAccessManager* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->cache()); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkAccessManager::clearAccessCache(QNetworkAccessManager* theWrappedObject) | ||||
| { | ||||
| ( theWrappedObject->clearAccessCache()); | ||||
| } | ||||
| QNetworkCookieJar* PythonQtWrapper_QNetworkAccessManager::cookieJar(QNetworkAccessManager* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->cookieJar()); | ||||
| } | ||||
| QNetworkReply* PythonQtWrapper_QNetworkAccessManager::createRequest(QNetworkAccessManager* theWrappedObject, QNetworkAccessManager::Operation op, const QNetworkRequest& request, QIODevice* outgoingData) | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QNetworkAccessManager*)theWrappedObject)->promoted_createRequest(op, request, outgoingData)); | ||||
| } | ||||
| QNetworkReply* PythonQtWrapper_QNetworkAccessManager::deleteResource(QNetworkAccessManager* theWrappedObject, const QNetworkRequest& request) | ||||
| { | ||||
| return ( theWrappedObject->deleteResource(request)); | ||||
| } | ||||
| QNetworkReply* PythonQtWrapper_QNetworkAccessManager::get(QNetworkAccessManager* theWrappedObject, const QNetworkRequest& request) | ||||
| { | ||||
| return ( theWrappedObject->get(request)); | ||||
| } | ||||
| QNetworkReply* PythonQtWrapper_QNetworkAccessManager::head(QNetworkAccessManager* theWrappedObject, const QNetworkRequest& request) | ||||
| { | ||||
| return ( theWrappedObject->head(request)); | ||||
| } | ||||
| QNetworkAccessManager::NetworkAccessibility PythonQtWrapper_QNetworkAccessManager::networkAccessible(QNetworkAccessManager* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->networkAccessible()); | ||||
| } | ||||
| QNetworkReply* PythonQtWrapper_QNetworkAccessManager::post(QNetworkAccessManager* theWrappedObject, const QNetworkRequest& request, QIODevice* data) | ||||
| { | ||||
| return ( theWrappedObject->post(request, data)); | ||||
| } | ||||
| QNetworkReply* PythonQtWrapper_QNetworkAccessManager::post(QNetworkAccessManager* theWrappedObject, const QNetworkRequest& request, const QByteArray& data) | ||||
| { | ||||
| return ( theWrappedObject->post(request, data)); | ||||
| } | ||||
| QNetworkProxy PythonQtWrapper_QNetworkAccessManager::proxy(QNetworkAccessManager* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->proxy()); | ||||
| } | ||||
| QNetworkProxyFactory* PythonQtWrapper_QNetworkAccessManager::proxyFactory(QNetworkAccessManager* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->proxyFactory()); | ||||
| } | ||||
| QNetworkReply* PythonQtWrapper_QNetworkAccessManager::put(QNetworkAccessManager* theWrappedObject, const QNetworkRequest& request, QIODevice* data) | ||||
| { | ||||
| return ( theWrappedObject->put(request, data)); | ||||
| } | ||||
| QNetworkReply* PythonQtWrapper_QNetworkAccessManager::put(QNetworkAccessManager* theWrappedObject, const QNetworkRequest& request, const QByteArray& data) | ||||
| { | ||||
| return ( theWrappedObject->put(request, data)); | ||||
| } | ||||
| QNetworkReply* PythonQtWrapper_QNetworkAccessManager::sendCustomRequest(QNetworkAccessManager* theWrappedObject, const QNetworkRequest& request, const QByteArray& verb, QIODevice* data) | ||||
| { | ||||
| return ( theWrappedObject->sendCustomRequest(request, verb, data)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkAccessManager::setCache(QNetworkAccessManager* theWrappedObject, QAbstractNetworkCache* cache) | ||||
| { | ||||
| ( theWrappedObject->setCache(cache)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkAccessManager::setCookieJar(QNetworkAccessManager* theWrappedObject, QNetworkCookieJar* cookieJar) | ||||
| { | ||||
| ( theWrappedObject->setCookieJar(cookieJar)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkAccessManager::setNetworkAccessible(QNetworkAccessManager* theWrappedObject, QNetworkAccessManager::NetworkAccessibility accessible) | ||||
| { | ||||
| ( theWrappedObject->setNetworkAccessible(accessible)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkAccessManager::setProxy(QNetworkAccessManager* theWrappedObject, const QNetworkProxy& proxy) | ||||
| { | ||||
| ( theWrappedObject->setProxy(proxy)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkAccessManager::setProxyFactory(QNetworkAccessManager* theWrappedObject, QNetworkProxyFactory* factory) | ||||
| { | ||||
| ( theWrappedObject->setProxyFactory(factory)); | ||||
| } | ||||
| QNetworkAddressEntry* PythonQtWrapper_QNetworkAddressEntry::new_QNetworkAddressEntry() | ||||
| { | ||||
| return new QNetworkAddressEntry(); } | ||||
| QNetworkAddressEntry* PythonQtWrapper_QNetworkAddressEntry::new_QNetworkAddressEntry(const QNetworkAddressEntry& other) | ||||
| { | ||||
| return new QNetworkAddressEntry(other); } | ||||
| QHostAddress PythonQtWrapper_QNetworkAddressEntry::broadcast(QNetworkAddressEntry* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->broadcast()); | ||||
| } | ||||
| QHostAddress PythonQtWrapper_QNetworkAddressEntry::ip(QNetworkAddressEntry* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->ip()); | ||||
| } | ||||
| QHostAddress PythonQtWrapper_QNetworkAddressEntry::netmask(QNetworkAddressEntry* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->netmask()); | ||||
| } | ||||
| bool PythonQtWrapper_QNetworkAddressEntry::__ne__(QNetworkAddressEntry* theWrappedObject, const QNetworkAddressEntry& other) const | ||||
| { | ||||
| return ( (*theWrappedObject)!= other); | ||||
| } | ||||
| bool PythonQtWrapper_QNetworkAddressEntry::__eq__(QNetworkAddressEntry* theWrappedObject, const QNetworkAddressEntry& other) const | ||||
| { | ||||
| return ( (*theWrappedObject)== other); | ||||
| } | ||||
| int PythonQtWrapper_QNetworkAddressEntry::prefixLength(QNetworkAddressEntry* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->prefixLength()); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkAddressEntry::setBroadcast(QNetworkAddressEntry* theWrappedObject, const QHostAddress& newBroadcast) | ||||
| { | ||||
| ( theWrappedObject->setBroadcast(newBroadcast)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkAddressEntry::setIp(QNetworkAddressEntry* theWrappedObject, const QHostAddress& newIp) | ||||
| { | ||||
| ( theWrappedObject->setIp(newIp)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkAddressEntry::setNetmask(QNetworkAddressEntry* theWrappedObject, const QHostAddress& newNetmask) | ||||
| { | ||||
| ( theWrappedObject->setNetmask(newNetmask)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkAddressEntry::setPrefixLength(QNetworkAddressEntry* theWrappedObject, int length) | ||||
| { | ||||
| ( theWrappedObject->setPrefixLength(length)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkAddressEntry::swap(QNetworkAddressEntry* theWrappedObject, QNetworkAddressEntry& other) | ||||
| { | ||||
| ( theWrappedObject->swap(other)); | ||||
| } | ||||
| QNetworkCacheMetaData* PythonQtWrapper_QNetworkCacheMetaData::new_QNetworkCacheMetaData() | ||||
| { | ||||
| return new QNetworkCacheMetaData(); } | ||||
| QNetworkCacheMetaData* PythonQtWrapper_QNetworkCacheMetaData::new_QNetworkCacheMetaData(const QNetworkCacheMetaData& other) | ||||
| { | ||||
| return new QNetworkCacheMetaData(other); } | ||||
| QHash<QNetworkRequest::Attribute , QVariant > PythonQtWrapper_QNetworkCacheMetaData::attributes(QNetworkCacheMetaData* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->attributes()); | ||||
| } | ||||
| QDateTime PythonQtWrapper_QNetworkCacheMetaData::expirationDate(QNetworkCacheMetaData* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->expirationDate()); | ||||
| } | ||||
| bool PythonQtWrapper_QNetworkCacheMetaData::isValid(QNetworkCacheMetaData* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->isValid()); | ||||
| } | ||||
| QDateTime PythonQtWrapper_QNetworkCacheMetaData::lastModified(QNetworkCacheMetaData* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->lastModified()); | ||||
| } | ||||
| bool PythonQtWrapper_QNetworkCacheMetaData::__ne__(QNetworkCacheMetaData* theWrappedObject, const QNetworkCacheMetaData& other) const | ||||
| { | ||||
| return ( (*theWrappedObject)!= other); | ||||
| } | ||||
| bool PythonQtWrapper_QNetworkCacheMetaData::__eq__(QNetworkCacheMetaData* theWrappedObject, const QNetworkCacheMetaData& other) const | ||||
| { | ||||
| return ( (*theWrappedObject)== other); | ||||
| } | ||||
| QList<QPair<QByteArray , QByteArray > > PythonQtWrapper_QNetworkCacheMetaData::rawHeaders(QNetworkCacheMetaData* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->rawHeaders()); | ||||
| } | ||||
| bool PythonQtWrapper_QNetworkCacheMetaData::saveToDisk(QNetworkCacheMetaData* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->saveToDisk()); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkCacheMetaData::setAttributes(QNetworkCacheMetaData* theWrappedObject, const QHash<QNetworkRequest::Attribute , QVariant >& attributes) | ||||
| { | ||||
| ( theWrappedObject->setAttributes(attributes)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkCacheMetaData::setExpirationDate(QNetworkCacheMetaData* theWrappedObject, const QDateTime& dateTime) | ||||
| { | ||||
| ( theWrappedObject->setExpirationDate(dateTime)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkCacheMetaData::setLastModified(QNetworkCacheMetaData* theWrappedObject, const QDateTime& dateTime) | ||||
| { | ||||
| ( theWrappedObject->setLastModified(dateTime)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkCacheMetaData::setRawHeaders(QNetworkCacheMetaData* theWrappedObject, const QList<QPair<QByteArray , QByteArray > >& headers) | ||||
| { | ||||
| ( theWrappedObject->setRawHeaders(headers)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkCacheMetaData::setSaveToDisk(QNetworkCacheMetaData* theWrappedObject, bool allow) | ||||
| { | ||||
| ( theWrappedObject->setSaveToDisk(allow)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkCacheMetaData::setUrl(QNetworkCacheMetaData* theWrappedObject, const QUrl& url) | ||||
| { | ||||
| ( theWrappedObject->setUrl(url)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkCacheMetaData::swap(QNetworkCacheMetaData* theWrappedObject, QNetworkCacheMetaData& other) | ||||
| { | ||||
| ( theWrappedObject->swap(other)); | ||||
| } | ||||
| QUrl PythonQtWrapper_QNetworkCacheMetaData::url(QNetworkCacheMetaData* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->url()); | ||||
| } | ||||
| QNetworkCookie* PythonQtWrapper_QNetworkCookie::new_QNetworkCookie(const QByteArray& name, const QByteArray& value) | ||||
| { | ||||
| return new QNetworkCookie(name, value); } | ||||
| QNetworkCookie* PythonQtWrapper_QNetworkCookie::new_QNetworkCookie(const QNetworkCookie& other) | ||||
| { | ||||
| return new QNetworkCookie(other); } | ||||
| QString PythonQtWrapper_QNetworkCookie::domain(QNetworkCookie* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->domain()); | ||||
| } | ||||
| QDateTime PythonQtWrapper_QNetworkCookie::expirationDate(QNetworkCookie* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->expirationDate()); | ||||
| } | ||||
| bool PythonQtWrapper_QNetworkCookie::hasSameIdentifier(QNetworkCookie* theWrappedObject, const QNetworkCookie& other) const | ||||
| { | ||||
| return ( theWrappedObject->hasSameIdentifier(other)); | ||||
| } | ||||
| bool PythonQtWrapper_QNetworkCookie::isHttpOnly(QNetworkCookie* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->isHttpOnly()); | ||||
| } | ||||
| bool PythonQtWrapper_QNetworkCookie::isSecure(QNetworkCookie* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->isSecure()); | ||||
| } | ||||
| bool PythonQtWrapper_QNetworkCookie::isSessionCookie(QNetworkCookie* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->isSessionCookie()); | ||||
| } | ||||
| QByteArray PythonQtWrapper_QNetworkCookie::name(QNetworkCookie* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->name()); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkCookie::normalize(QNetworkCookie* theWrappedObject, const QUrl& url) | ||||
| { | ||||
| ( theWrappedObject->normalize(url)); | ||||
| } | ||||
| bool PythonQtWrapper_QNetworkCookie::__ne__(QNetworkCookie* theWrappedObject, const QNetworkCookie& other) const | ||||
| { | ||||
| return ( (*theWrappedObject)!= other); | ||||
| } | ||||
| bool PythonQtWrapper_QNetworkCookie::__eq__(QNetworkCookie* theWrappedObject, const QNetworkCookie& other) const | ||||
| { | ||||
| return ( (*theWrappedObject)== other); | ||||
| } | ||||
| QList<QNetworkCookie > PythonQtWrapper_QNetworkCookie::static_QNetworkCookie_parseCookies(const QByteArray& cookieString) | ||||
| { | ||||
| return (QNetworkCookie::parseCookies(cookieString)); | ||||
| } | ||||
| QString PythonQtWrapper_QNetworkCookie::path(QNetworkCookie* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->path()); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkCookie::setDomain(QNetworkCookie* theWrappedObject, const QString& domain) | ||||
| { | ||||
| ( theWrappedObject->setDomain(domain)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkCookie::setExpirationDate(QNetworkCookie* theWrappedObject, const QDateTime& date) | ||||
| { | ||||
| ( theWrappedObject->setExpirationDate(date)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkCookie::setHttpOnly(QNetworkCookie* theWrappedObject, bool enable) | ||||
| { | ||||
| ( theWrappedObject->setHttpOnly(enable)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkCookie::setName(QNetworkCookie* theWrappedObject, const QByteArray& cookieName) | ||||
| { | ||||
| ( theWrappedObject->setName(cookieName)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkCookie::setPath(QNetworkCookie* theWrappedObject, const QString& path) | ||||
| { | ||||
| ( theWrappedObject->setPath(path)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkCookie::setSecure(QNetworkCookie* theWrappedObject, bool enable) | ||||
| { | ||||
| ( theWrappedObject->setSecure(enable)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkCookie::setValue(QNetworkCookie* theWrappedObject, const QByteArray& value) | ||||
| { | ||||
| ( theWrappedObject->setValue(value)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkCookie::swap(QNetworkCookie* theWrappedObject, QNetworkCookie& other) | ||||
| { | ||||
| ( theWrappedObject->swap(other)); | ||||
| } | ||||
| QByteArray PythonQtWrapper_QNetworkCookie::toRawForm(QNetworkCookie* theWrappedObject, QNetworkCookie::RawForm form) const | ||||
| { | ||||
| return ( theWrappedObject->toRawForm(form)); | ||||
| } | ||||
| QByteArray PythonQtWrapper_QNetworkCookie::value(QNetworkCookie* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->value()); | ||||
| } | ||||
| QString PythonQtWrapper_QNetworkCookie::py_toString(QNetworkCookie* obj) { | ||||
| QString result; | ||||
| QDebug d(&result); | ||||
| d << *obj; | ||||
| return result; | ||||
| } | ||||
| PythonQtShell_QNetworkCookieJar::~PythonQtShell_QNetworkCookieJar() { | ||||
| PythonQtPrivate* priv = PythonQt::priv(); | ||||
| if (priv) { priv->shellClassDeleted(this); } | ||||
| } | ||||
| void PythonQtShell_QNetworkCookieJar::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; | ||||
| } | ||||
| } | ||||
| QNetworkCookieJar::childEvent(arg__1); | ||||
| } | ||||
| QList<QNetworkCookie > PythonQtShell_QNetworkCookieJar::cookiesForUrl(const QUrl& url) const | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "cookiesForUrl"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"QList<QNetworkCookie >" , "const QUrl&"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| QList<QNetworkCookie > returnValue; | ||||
| void* args[2] = {NULL, (void*)&url}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { | ||||
| args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
| if (args[0]!=&returnValue) { | ||||
| if (args[0]==NULL) { | ||||
| PythonQt::priv()->handleVirtualOverloadReturnError("cookiesForUrl", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((QList<QNetworkCookie >*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QNetworkCookieJar::cookiesForUrl(url); | ||||
| } | ||||
| void PythonQtShell_QNetworkCookieJar::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; | ||||
| } | ||||
| } | ||||
| QNetworkCookieJar::customEvent(arg__1); | ||||
| } | ||||
| bool PythonQtShell_QNetworkCookieJar::deleteCookie(const QNetworkCookie& cookie) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "deleteCookie"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"bool" , "const QNetworkCookie&"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| bool returnValue; | ||||
| void* args[2] = {NULL, (void*)&cookie}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { | ||||
| args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
| if (args[0]!=&returnValue) { | ||||
| if (args[0]==NULL) { | ||||
| PythonQt::priv()->handleVirtualOverloadReturnError("deleteCookie", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((bool*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QNetworkCookieJar::deleteCookie(cookie); | ||||
| } | ||||
| bool PythonQtShell_QNetworkCookieJar::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 QNetworkCookieJar::event(arg__1); | ||||
| } | ||||
| bool PythonQtShell_QNetworkCookieJar::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 QNetworkCookieJar::eventFilter(arg__1, arg__2); | ||||
| } | ||||
| bool PythonQtShell_QNetworkCookieJar::insertCookie(const QNetworkCookie& cookie) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "insertCookie"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"bool" , "const QNetworkCookie&"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| bool returnValue; | ||||
| void* args[2] = {NULL, (void*)&cookie}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { | ||||
| args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
| if (args[0]!=&returnValue) { | ||||
| if (args[0]==NULL) { | ||||
| PythonQt::priv()->handleVirtualOverloadReturnError("insertCookie", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((bool*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QNetworkCookieJar::insertCookie(cookie); | ||||
| } | ||||
| bool PythonQtShell_QNetworkCookieJar::setCookiesFromUrl(const QList<QNetworkCookie >& cookieList, const QUrl& url) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setCookiesFromUrl"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"bool" , "const QList<QNetworkCookie >&" , "const QUrl&"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
| bool returnValue; | ||||
| void* args[3] = {NULL, (void*)&cookieList, (void*)&url}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { | ||||
| args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
| if (args[0]!=&returnValue) { | ||||
| if (args[0]==NULL) { | ||||
| PythonQt::priv()->handleVirtualOverloadReturnError("setCookiesFromUrl", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((bool*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QNetworkCookieJar::setCookiesFromUrl(cookieList, url); | ||||
| } | ||||
| void PythonQtShell_QNetworkCookieJar::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; | ||||
| } | ||||
| } | ||||
| QNetworkCookieJar::timerEvent(arg__1); | ||||
| } | ||||
| bool PythonQtShell_QNetworkCookieJar::updateCookie(const QNetworkCookie& cookie) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateCookie"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"bool" , "const QNetworkCookie&"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| bool returnValue; | ||||
| void* args[2] = {NULL, (void*)&cookie}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { | ||||
| args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
| if (args[0]!=&returnValue) { | ||||
| if (args[0]==NULL) { | ||||
| PythonQt::priv()->handleVirtualOverloadReturnError("updateCookie", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((bool*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QNetworkCookieJar::updateCookie(cookie); | ||||
| } | ||||
| bool PythonQtShell_QNetworkCookieJar::validateCookie(const QNetworkCookie& cookie, const QUrl& url) const | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "validateCookie"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"bool" , "const QNetworkCookie&" , "const QUrl&"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
| bool returnValue; | ||||
| void* args[3] = {NULL, (void*)&cookie, (void*)&url}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { | ||||
| args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
| if (args[0]!=&returnValue) { | ||||
| if (args[0]==NULL) { | ||||
| PythonQt::priv()->handleVirtualOverloadReturnError("validateCookie", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((bool*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QNetworkCookieJar::validateCookie(cookie, url); | ||||
| } | ||||
| QNetworkCookieJar* PythonQtWrapper_QNetworkCookieJar::new_QNetworkCookieJar(QObject* parent) | ||||
| { | ||||
| return new PythonQtShell_QNetworkCookieJar(parent); } | ||||
| QList<QNetworkCookie > PythonQtWrapper_QNetworkCookieJar::cookiesForUrl(QNetworkCookieJar* theWrappedObject, const QUrl& url) const | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QNetworkCookieJar*)theWrappedObject)->promoted_cookiesForUrl(url)); | ||||
| } | ||||
| bool PythonQtWrapper_QNetworkCookieJar::deleteCookie(QNetworkCookieJar* theWrappedObject, const QNetworkCookie& cookie) | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QNetworkCookieJar*)theWrappedObject)->promoted_deleteCookie(cookie)); | ||||
| } | ||||
| bool PythonQtWrapper_QNetworkCookieJar::insertCookie(QNetworkCookieJar* theWrappedObject, const QNetworkCookie& cookie) | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QNetworkCookieJar*)theWrappedObject)->promoted_insertCookie(cookie)); | ||||
| } | ||||
| bool PythonQtWrapper_QNetworkCookieJar::setCookiesFromUrl(QNetworkCookieJar* theWrappedObject, const QList<QNetworkCookie >& cookieList, const QUrl& url) | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QNetworkCookieJar*)theWrappedObject)->promoted_setCookiesFromUrl(cookieList, url)); | ||||
| } | ||||
| bool PythonQtWrapper_QNetworkCookieJar::updateCookie(QNetworkCookieJar* theWrappedObject, const QNetworkCookie& cookie) | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QNetworkCookieJar*)theWrappedObject)->promoted_updateCookie(cookie)); | ||||
| } | ||||
| bool PythonQtWrapper_QNetworkCookieJar::validateCookie(QNetworkCookieJar* theWrappedObject, const QNetworkCookie& cookie, const QUrl& url) const | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QNetworkCookieJar*)theWrappedObject)->promoted_validateCookie(cookie, url)); | ||||
| } | ||||
| PythonQtShell_QNetworkDiskCache::~PythonQtShell_QNetworkDiskCache() { | ||||
| PythonQtPrivate* priv = PythonQt::priv(); | ||||
| if (priv) { priv->shellClassDeleted(this); } | ||||
| } | ||||
| qint64 PythonQtShell_QNetworkDiskCache::cacheSize() const | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "cacheSize"); | ||||
| 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("cacheSize", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((qint64*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QNetworkDiskCache::cacheSize(); | ||||
| } | ||||
| void PythonQtShell_QNetworkDiskCache::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; | ||||
| } | ||||
| } | ||||
| QNetworkDiskCache::childEvent(arg__1); | ||||
| } | ||||
| void PythonQtShell_QNetworkDiskCache::clear() | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "clear"); | ||||
| 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; | ||||
| } | ||||
| } | ||||
| QNetworkDiskCache::clear(); | ||||
| } | ||||
| void PythonQtShell_QNetworkDiskCache::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; | ||||
| } | ||||
| } | ||||
| QNetworkDiskCache::customEvent(arg__1); | ||||
| } | ||||
| QIODevice* PythonQtShell_QNetworkDiskCache::data(const QUrl& url) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "data"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"QIODevice*" , "const QUrl&"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| QIODevice* returnValue; | ||||
| void* args[2] = {NULL, (void*)&url}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { | ||||
| args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
| if (args[0]!=&returnValue) { | ||||
| if (args[0]==NULL) { | ||||
| PythonQt::priv()->handleVirtualOverloadReturnError("data", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((QIODevice**)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QNetworkDiskCache::data(url); | ||||
| } | ||||
| bool PythonQtShell_QNetworkDiskCache::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 QNetworkDiskCache::event(arg__1); | ||||
| } | ||||
| bool PythonQtShell_QNetworkDiskCache::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 QNetworkDiskCache::eventFilter(arg__1, arg__2); | ||||
| } | ||||
| qint64 PythonQtShell_QNetworkDiskCache::expire() | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "expire"); | ||||
| 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("expire", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((qint64*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QNetworkDiskCache::expire(); | ||||
| } | ||||
| void PythonQtShell_QNetworkDiskCache::insert(QIODevice* device) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "insert"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"" , "QIODevice*"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| void* args[2] = {NULL, (void*)&device}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return; | ||||
| } | ||||
| } | ||||
| QNetworkDiskCache::insert(device); | ||||
| } | ||||
| QNetworkCacheMetaData PythonQtShell_QNetworkDiskCache::metaData(const QUrl& url) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metaData"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"QNetworkCacheMetaData" , "const QUrl&"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| QNetworkCacheMetaData returnValue; | ||||
| void* args[2] = {NULL, (void*)&url}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { | ||||
| args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
| if (args[0]!=&returnValue) { | ||||
| if (args[0]==NULL) { | ||||
| PythonQt::priv()->handleVirtualOverloadReturnError("metaData", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((QNetworkCacheMetaData*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QNetworkDiskCache::metaData(url); | ||||
| } | ||||
| QIODevice* PythonQtShell_QNetworkDiskCache::prepare(const QNetworkCacheMetaData& metaData) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "prepare"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"QIODevice*" , "const QNetworkCacheMetaData&"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| QIODevice* returnValue; | ||||
| void* args[2] = {NULL, (void*)&metaData}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { | ||||
| args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
| if (args[0]!=&returnValue) { | ||||
| if (args[0]==NULL) { | ||||
| PythonQt::priv()->handleVirtualOverloadReturnError("prepare", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((QIODevice**)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QNetworkDiskCache::prepare(metaData); | ||||
| } | ||||
| bool PythonQtShell_QNetworkDiskCache::remove(const QUrl& url) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "remove"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"bool" , "const QUrl&"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| bool returnValue; | ||||
| void* args[2] = {NULL, (void*)&url}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { | ||||
| args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
| if (args[0]!=&returnValue) { | ||||
| if (args[0]==NULL) { | ||||
| PythonQt::priv()->handleVirtualOverloadReturnError("remove", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((bool*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QNetworkDiskCache::remove(url); | ||||
| } | ||||
| void PythonQtShell_QNetworkDiskCache::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; | ||||
| } | ||||
| } | ||||
| QNetworkDiskCache::timerEvent(arg__1); | ||||
| } | ||||
| void PythonQtShell_QNetworkDiskCache::updateMetaData(const QNetworkCacheMetaData& metaData) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateMetaData"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"" , "const QNetworkCacheMetaData&"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| void* args[2] = {NULL, (void*)&metaData}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return; | ||||
| } | ||||
| } | ||||
| QNetworkDiskCache::updateMetaData(metaData); | ||||
| } | ||||
| QNetworkDiskCache* PythonQtWrapper_QNetworkDiskCache::new_QNetworkDiskCache(QObject* parent) | ||||
| { | ||||
| return new PythonQtShell_QNetworkDiskCache(parent); } | ||||
| QString PythonQtWrapper_QNetworkDiskCache::cacheDirectory(QNetworkDiskCache* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->cacheDirectory()); | ||||
| } | ||||
| qint64 PythonQtWrapper_QNetworkDiskCache::cacheSize(QNetworkDiskCache* theWrappedObject) const | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QNetworkDiskCache*)theWrappedObject)->promoted_cacheSize()); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkDiskCache::clear(QNetworkDiskCache* theWrappedObject) | ||||
| { | ||||
| ( ((PythonQtPublicPromoter_QNetworkDiskCache*)theWrappedObject)->promoted_clear()); | ||||
| } | ||||
| QIODevice* PythonQtWrapper_QNetworkDiskCache::data(QNetworkDiskCache* theWrappedObject, const QUrl& url) | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QNetworkDiskCache*)theWrappedObject)->promoted_data(url)); | ||||
| } | ||||
| qint64 PythonQtWrapper_QNetworkDiskCache::expire(QNetworkDiskCache* theWrappedObject) | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QNetworkDiskCache*)theWrappedObject)->promoted_expire()); | ||||
| } | ||||
| QNetworkCacheMetaData PythonQtWrapper_QNetworkDiskCache::fileMetaData(QNetworkDiskCache* theWrappedObject, const QString& fileName) const | ||||
| { | ||||
| return ( theWrappedObject->fileMetaData(fileName)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkDiskCache::insert(QNetworkDiskCache* theWrappedObject, QIODevice* device) | ||||
| { | ||||
| ( ((PythonQtPublicPromoter_QNetworkDiskCache*)theWrappedObject)->promoted_insert(device)); | ||||
| } | ||||
| qint64 PythonQtWrapper_QNetworkDiskCache::maximumCacheSize(QNetworkDiskCache* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->maximumCacheSize()); | ||||
| } | ||||
| QNetworkCacheMetaData PythonQtWrapper_QNetworkDiskCache::metaData(QNetworkDiskCache* theWrappedObject, const QUrl& url) | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QNetworkDiskCache*)theWrappedObject)->promoted_metaData(url)); | ||||
| } | ||||
| QIODevice* PythonQtWrapper_QNetworkDiskCache::prepare(QNetworkDiskCache* theWrappedObject, const QNetworkCacheMetaData& metaData) | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QNetworkDiskCache*)theWrappedObject)->promoted_prepare(metaData)); | ||||
| } | ||||
| bool PythonQtWrapper_QNetworkDiskCache::remove(QNetworkDiskCache* theWrappedObject, const QUrl& url) | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QNetworkDiskCache*)theWrappedObject)->promoted_remove(url)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkDiskCache::setCacheDirectory(QNetworkDiskCache* theWrappedObject, const QString& cacheDir) | ||||
| { | ||||
| ( theWrappedObject->setCacheDirectory(cacheDir)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkDiskCache::setMaximumCacheSize(QNetworkDiskCache* theWrappedObject, qint64 size) | ||||
| { | ||||
| ( theWrappedObject->setMaximumCacheSize(size)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkDiskCache::updateMetaData(QNetworkDiskCache* theWrappedObject, const QNetworkCacheMetaData& metaData) | ||||
| { | ||||
| ( ((PythonQtPublicPromoter_QNetworkDiskCache*)theWrappedObject)->promoted_updateMetaData(metaData)); | ||||
| } | ||||
| QNetworkInterface* PythonQtWrapper_QNetworkInterface::new_QNetworkInterface() | ||||
| { | ||||
| return new QNetworkInterface(); } | ||||
| QNetworkInterface* PythonQtWrapper_QNetworkInterface::new_QNetworkInterface(const QNetworkInterface& other) | ||||
| { | ||||
| return new QNetworkInterface(other); } | ||||
| QList<QNetworkAddressEntry > PythonQtWrapper_QNetworkInterface::addressEntries(QNetworkInterface* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->addressEntries()); | ||||
| } | ||||
| QList<QHostAddress > PythonQtWrapper_QNetworkInterface::static_QNetworkInterface_allAddresses() | ||||
| { | ||||
| return (QNetworkInterface::allAddresses()); | ||||
| } | ||||
| QList<QNetworkInterface > PythonQtWrapper_QNetworkInterface::static_QNetworkInterface_allInterfaces() | ||||
| { | ||||
| return (QNetworkInterface::allInterfaces()); | ||||
| } | ||||
| QNetworkInterface::InterfaceFlags PythonQtWrapper_QNetworkInterface::flags(QNetworkInterface* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->flags()); | ||||
| } | ||||
| QString PythonQtWrapper_QNetworkInterface::hardwareAddress(QNetworkInterface* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->hardwareAddress()); | ||||
| } | ||||
| QString PythonQtWrapper_QNetworkInterface::humanReadableName(QNetworkInterface* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->humanReadableName()); | ||||
| } | ||||
| int PythonQtWrapper_QNetworkInterface::index(QNetworkInterface* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->index()); | ||||
| } | ||||
| QNetworkInterface PythonQtWrapper_QNetworkInterface::static_QNetworkInterface_interfaceFromIndex(int index) | ||||
| { | ||||
| return (QNetworkInterface::interfaceFromIndex(index)); | ||||
| } | ||||
| QNetworkInterface PythonQtWrapper_QNetworkInterface::static_QNetworkInterface_interfaceFromName(const QString& name) | ||||
| { | ||||
| return (QNetworkInterface::interfaceFromName(name)); | ||||
| } | ||||
| bool PythonQtWrapper_QNetworkInterface::isValid(QNetworkInterface* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->isValid()); | ||||
| } | ||||
| QString PythonQtWrapper_QNetworkInterface::name(QNetworkInterface* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->name()); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkInterface::swap(QNetworkInterface* theWrappedObject, QNetworkInterface& other) | ||||
| { | ||||
| ( theWrappedObject->swap(other)); | ||||
| } | ||||
| QString PythonQtWrapper_QNetworkInterface::py_toString(QNetworkInterface* obj) { | ||||
| QString result; | ||||
| QDebug d(&result); | ||||
| d << *obj; | ||||
| return result; | ||||
| } | ||||
| QNetworkProxy* PythonQtWrapper_QNetworkProxy::new_QNetworkProxy() | ||||
| { | ||||
| return new QNetworkProxy(); } | ||||
| QNetworkProxy* PythonQtWrapper_QNetworkProxy::new_QNetworkProxy(QNetworkProxy::ProxyType type, const QString& hostName, unsigned short port, const QString& user, const QString& password) | ||||
| { | ||||
| return new QNetworkProxy(type, hostName, port, user, password); } | ||||
| QNetworkProxy* PythonQtWrapper_QNetworkProxy::new_QNetworkProxy(const QNetworkProxy& other) | ||||
| { | ||||
| return new QNetworkProxy(other); } | ||||
| QNetworkProxy PythonQtWrapper_QNetworkProxy::static_QNetworkProxy_applicationProxy() | ||||
| { | ||||
| return (QNetworkProxy::applicationProxy()); | ||||
| } | ||||
| QNetworkProxy::Capabilities PythonQtWrapper_QNetworkProxy::capabilities(QNetworkProxy* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->capabilities()); | ||||
| } | ||||
| bool PythonQtWrapper_QNetworkProxy::hasRawHeader(QNetworkProxy* theWrappedObject, const QByteArray& headerName) const | ||||
| { | ||||
| return ( theWrappedObject->hasRawHeader(headerName)); | ||||
| } | ||||
| QVariant PythonQtWrapper_QNetworkProxy::header(QNetworkProxy* theWrappedObject, QNetworkRequest::KnownHeaders header) const | ||||
| { | ||||
| return ( theWrappedObject->header(header)); | ||||
| } | ||||
| QString PythonQtWrapper_QNetworkProxy::hostName(QNetworkProxy* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->hostName()); | ||||
| } | ||||
| bool PythonQtWrapper_QNetworkProxy::isCachingProxy(QNetworkProxy* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->isCachingProxy()); | ||||
| } | ||||
| bool PythonQtWrapper_QNetworkProxy::isTransparentProxy(QNetworkProxy* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->isTransparentProxy()); | ||||
| } | ||||
| bool PythonQtWrapper_QNetworkProxy::__ne__(QNetworkProxy* theWrappedObject, const QNetworkProxy& other) const | ||||
| { | ||||
| return ( (*theWrappedObject)!= other); | ||||
| } | ||||
| bool PythonQtWrapper_QNetworkProxy::__eq__(QNetworkProxy* theWrappedObject, const QNetworkProxy& other) const | ||||
| { | ||||
| return ( (*theWrappedObject)== other); | ||||
| } | ||||
| QString PythonQtWrapper_QNetworkProxy::password(QNetworkProxy* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->password()); | ||||
| } | ||||
| unsigned short PythonQtWrapper_QNetworkProxy::port(QNetworkProxy* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->port()); | ||||
| } | ||||
| QByteArray PythonQtWrapper_QNetworkProxy::rawHeader(QNetworkProxy* theWrappedObject, const QByteArray& headerName) const | ||||
| { | ||||
| return ( theWrappedObject->rawHeader(headerName)); | ||||
| } | ||||
| QList<QByteArray > PythonQtWrapper_QNetworkProxy::rawHeaderList(QNetworkProxy* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->rawHeaderList()); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkProxy::static_QNetworkProxy_setApplicationProxy(const QNetworkProxy& proxy) | ||||
| { | ||||
| (QNetworkProxy::setApplicationProxy(proxy)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkProxy::setCapabilities(QNetworkProxy* theWrappedObject, QNetworkProxy::Capabilities capab) | ||||
| { | ||||
| ( theWrappedObject->setCapabilities(capab)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkProxy::setHeader(QNetworkProxy* theWrappedObject, QNetworkRequest::KnownHeaders header, const QVariant& value) | ||||
| { | ||||
| ( theWrappedObject->setHeader(header, value)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkProxy::setHostName(QNetworkProxy* theWrappedObject, const QString& hostName) | ||||
| { | ||||
| ( theWrappedObject->setHostName(hostName)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkProxy::setPassword(QNetworkProxy* theWrappedObject, const QString& password) | ||||
| { | ||||
| ( theWrappedObject->setPassword(password)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkProxy::setPort(QNetworkProxy* theWrappedObject, unsigned short port) | ||||
| { | ||||
| ( theWrappedObject->setPort(port)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkProxy::setRawHeader(QNetworkProxy* theWrappedObject, const QByteArray& headerName, const QByteArray& value) | ||||
| { | ||||
| ( theWrappedObject->setRawHeader(headerName, value)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkProxy::setType(QNetworkProxy* theWrappedObject, QNetworkProxy::ProxyType type) | ||||
| { | ||||
| ( theWrappedObject->setType(type)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkProxy::setUser(QNetworkProxy* theWrappedObject, const QString& userName) | ||||
| { | ||||
| ( theWrappedObject->setUser(userName)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkProxy::swap(QNetworkProxy* theWrappedObject, QNetworkProxy& other) | ||||
| { | ||||
| ( theWrappedObject->swap(other)); | ||||
| } | ||||
| QNetworkProxy::ProxyType PythonQtWrapper_QNetworkProxy::type(QNetworkProxy* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->type()); | ||||
| } | ||||
| QString PythonQtWrapper_QNetworkProxy::user(QNetworkProxy* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->user()); | ||||
| } | ||||
| QString PythonQtWrapper_QNetworkProxy::py_toString(QNetworkProxy* obj) { | ||||
| QString result; | ||||
| QDebug d(&result); | ||||
| d << *obj; | ||||
| return result; | ||||
| } | ||||
| PythonQtShell_QNetworkProxyFactory::~PythonQtShell_QNetworkProxyFactory() { | ||||
| PythonQtPrivate* priv = PythonQt::priv(); | ||||
| if (priv) { priv->shellClassDeleted(this); } | ||||
| } | ||||
| QList<QNetworkProxy > PythonQtShell_QNetworkProxyFactory::queryProxy(const QNetworkProxyQuery& query) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "queryProxy"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"QList<QNetworkProxy >" , "const QNetworkProxyQuery&"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| QList<QNetworkProxy > returnValue; | ||||
| void* args[2] = {NULL, (void*)&query}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { | ||||
| args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
| if (args[0]!=&returnValue) { | ||||
| if (args[0]==NULL) { | ||||
| PythonQt::priv()->handleVirtualOverloadReturnError("queryProxy", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((QList<QNetworkProxy >*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QList<QNetworkProxy >(); | ||||
| } | ||||
| QNetworkProxyFactory* PythonQtWrapper_QNetworkProxyFactory::new_QNetworkProxyFactory() | ||||
| { | ||||
| return new PythonQtShell_QNetworkProxyFactory(); } | ||||
| QList<QNetworkProxy > PythonQtWrapper_QNetworkProxyFactory::static_QNetworkProxyFactory_proxyForQuery(const QNetworkProxyQuery& query) | ||||
| { | ||||
| return (QNetworkProxyFactory::proxyForQuery(query)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkProxyFactory::static_QNetworkProxyFactory_setApplicationProxyFactory(QNetworkProxyFactory* factory) | ||||
| { | ||||
| (QNetworkProxyFactory::setApplicationProxyFactory(factory)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkProxyFactory::static_QNetworkProxyFactory_setUseSystemConfiguration(bool enable) | ||||
| { | ||||
| (QNetworkProxyFactory::setUseSystemConfiguration(enable)); | ||||
| } | ||||
| QList<QNetworkProxy > PythonQtWrapper_QNetworkProxyFactory::static_QNetworkProxyFactory_systemProxyForQuery(const QNetworkProxyQuery& query) | ||||
| { | ||||
| return (QNetworkProxyFactory::systemProxyForQuery(query)); | ||||
| } | ||||
| QNetworkProxyQuery* PythonQtWrapper_QNetworkProxyQuery::new_QNetworkProxyQuery() | ||||
| { | ||||
| return new QNetworkProxyQuery(); } | ||||
| QNetworkProxyQuery* PythonQtWrapper_QNetworkProxyQuery::new_QNetworkProxyQuery(const QNetworkProxyQuery& other) | ||||
| { | ||||
| return new QNetworkProxyQuery(other); } | ||||
| QNetworkProxyQuery* PythonQtWrapper_QNetworkProxyQuery::new_QNetworkProxyQuery(const QString& hostname, int port, const QString& protocolTag, QNetworkProxyQuery::QueryType queryType) | ||||
| { | ||||
| return new QNetworkProxyQuery(hostname, port, protocolTag, queryType); } | ||||
| QNetworkProxyQuery* PythonQtWrapper_QNetworkProxyQuery::new_QNetworkProxyQuery(const QUrl& requestUrl, QNetworkProxyQuery::QueryType queryType) | ||||
| { | ||||
| return new QNetworkProxyQuery(requestUrl, queryType); } | ||||
| QNetworkProxyQuery* PythonQtWrapper_QNetworkProxyQuery::new_QNetworkProxyQuery(unsigned short bindPort, const QString& protocolTag, QNetworkProxyQuery::QueryType queryType) | ||||
| { | ||||
| return new QNetworkProxyQuery(bindPort, protocolTag, queryType); } | ||||
| int PythonQtWrapper_QNetworkProxyQuery::localPort(QNetworkProxyQuery* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->localPort()); | ||||
| } | ||||
| bool PythonQtWrapper_QNetworkProxyQuery::__ne__(QNetworkProxyQuery* theWrappedObject, const QNetworkProxyQuery& other) const | ||||
| { | ||||
| return ( (*theWrappedObject)!= other); | ||||
| } | ||||
| bool PythonQtWrapper_QNetworkProxyQuery::__eq__(QNetworkProxyQuery* theWrappedObject, const QNetworkProxyQuery& other) const | ||||
| { | ||||
| return ( (*theWrappedObject)== other); | ||||
| } | ||||
| QString PythonQtWrapper_QNetworkProxyQuery::peerHostName(QNetworkProxyQuery* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->peerHostName()); | ||||
| } | ||||
| int PythonQtWrapper_QNetworkProxyQuery::peerPort(QNetworkProxyQuery* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->peerPort()); | ||||
| } | ||||
| QString PythonQtWrapper_QNetworkProxyQuery::protocolTag(QNetworkProxyQuery* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->protocolTag()); | ||||
| } | ||||
| QNetworkProxyQuery::QueryType PythonQtWrapper_QNetworkProxyQuery::queryType(QNetworkProxyQuery* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->queryType()); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkProxyQuery::setLocalPort(QNetworkProxyQuery* theWrappedObject, int port) | ||||
| { | ||||
| ( theWrappedObject->setLocalPort(port)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkProxyQuery::setPeerHostName(QNetworkProxyQuery* theWrappedObject, const QString& hostname) | ||||
| { | ||||
| ( theWrappedObject->setPeerHostName(hostname)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkProxyQuery::setPeerPort(QNetworkProxyQuery* theWrappedObject, int port) | ||||
| { | ||||
| ( theWrappedObject->setPeerPort(port)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkProxyQuery::setProtocolTag(QNetworkProxyQuery* theWrappedObject, const QString& protocolTag) | ||||
| { | ||||
| ( theWrappedObject->setProtocolTag(protocolTag)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkProxyQuery::setQueryType(QNetworkProxyQuery* theWrappedObject, QNetworkProxyQuery::QueryType type) | ||||
| { | ||||
| ( theWrappedObject->setQueryType(type)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkProxyQuery::setUrl(QNetworkProxyQuery* theWrappedObject, const QUrl& url) | ||||
| { | ||||
| ( theWrappedObject->setUrl(url)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkProxyQuery::swap(QNetworkProxyQuery* theWrappedObject, QNetworkProxyQuery& other) | ||||
| { | ||||
| ( theWrappedObject->swap(other)); | ||||
| } | ||||
| QUrl PythonQtWrapper_QNetworkProxyQuery::url(QNetworkProxyQuery* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->url()); | ||||
| } | ||||
| PythonQtShell_QNetworkReply::~PythonQtShell_QNetworkReply() { | ||||
| PythonQtPrivate* priv = PythonQt::priv(); | ||||
| if (priv) { priv->shellClassDeleted(this); } | ||||
| } | ||||
| void PythonQtShell_QNetworkReply::abort() | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "abort"); | ||||
| 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; | ||||
| } | ||||
| } | ||||
| } | ||||
| bool PythonQtShell_QNetworkReply::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 QNetworkReply::atEnd(); | ||||
| } | ||||
| qint64 PythonQtShell_QNetworkReply::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 QNetworkReply::bytesAvailable(); | ||||
| } | ||||
| qint64 PythonQtShell_QNetworkReply::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 QNetworkReply::bytesToWrite(); | ||||
| } | ||||
| bool PythonQtShell_QNetworkReply::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 QNetworkReply::canReadLine(); | ||||
| } | ||||
| void PythonQtShell_QNetworkReply::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; | ||||
| } | ||||
| } | ||||
| QNetworkReply::childEvent(arg__1); | ||||
| } | ||||
| void PythonQtShell_QNetworkReply::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; | ||||
| } | ||||
| } | ||||
| QNetworkReply::close(); | ||||
| } | ||||
| void PythonQtShell_QNetworkReply::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; | ||||
| } | ||||
| } | ||||
| QNetworkReply::customEvent(arg__1); | ||||
| } | ||||
| bool PythonQtShell_QNetworkReply::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 QNetworkReply::event(arg__1); | ||||
| } | ||||
| bool PythonQtShell_QNetworkReply::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 QNetworkReply::eventFilter(arg__1, arg__2); | ||||
| } | ||||
| void PythonQtShell_QNetworkReply::ignoreSslErrors() | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "ignoreSslErrors"); | ||||
| 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; | ||||
| } | ||||
| } | ||||
| QNetworkReply::ignoreSslErrors(); | ||||
| } | ||||
| void PythonQtShell_QNetworkReply::ignoreSslErrorsImplementation(const QList<QSslError >& arg__1) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "ignoreSslErrorsImplementation"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"" , "const QList<QSslError >&"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| void* args[2] = {NULL, (void*)&arg__1}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return; | ||||
| } | ||||
| } | ||||
| QNetworkReply::ignoreSslErrorsImplementation(arg__1); | ||||
| } | ||||
| bool PythonQtShell_QNetworkReply::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 QNetworkReply::isSequential(); | ||||
| } | ||||
| bool PythonQtShell_QNetworkReply::open(QIODevice::OpenMode mode) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "open"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"bool" , "QIODevice::OpenMode"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| bool returnValue; | ||||
| void* args[2] = {NULL, (void*)&mode}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { | ||||
| args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
| if (args[0]!=&returnValue) { | ||||
| if (args[0]==NULL) { | ||||
| PythonQt::priv()->handleVirtualOverloadReturnError("open", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((bool*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QNetworkReply::open(mode); | ||||
| } | ||||
| qint64 PythonQtShell_QNetworkReply::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 QNetworkReply::pos(); | ||||
| } | ||||
| qint64 PythonQtShell_QNetworkReply::readData(char* data, qint64 maxlen) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "readData"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"qint64" , "char*" , "qint64"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
| qint64 returnValue; | ||||
| void* args[3] = {NULL, (void*)&data, (void*)&maxlen}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { | ||||
| args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
| if (args[0]!=&returnValue) { | ||||
| if (args[0]==NULL) { | ||||
| PythonQt::priv()->handleVirtualOverloadReturnError("readData", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((qint64*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return qint64(); | ||||
| } | ||||
| qint64 PythonQtShell_QNetworkReply::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 QNetworkReply::readLineData(data, maxlen); | ||||
| } | ||||
| bool PythonQtShell_QNetworkReply::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 QNetworkReply::reset(); | ||||
| } | ||||
| bool PythonQtShell_QNetworkReply::seek(qint64 pos) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "seek"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"bool" , "qint64"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| bool returnValue; | ||||
| void* args[2] = {NULL, (void*)&pos}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { | ||||
| args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
| if (args[0]!=&returnValue) { | ||||
| if (args[0]==NULL) { | ||||
| PythonQt::priv()->handleVirtualOverloadReturnError("seek", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((bool*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QNetworkReply::seek(pos); | ||||
| } | ||||
| void PythonQtShell_QNetworkReply::setReadBufferSize(qint64 size) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setReadBufferSize"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"" , "qint64"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| void* args[2] = {NULL, (void*)&size}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return; | ||||
| } | ||||
| } | ||||
| QNetworkReply::setReadBufferSize(size); | ||||
| } | ||||
| void PythonQtShell_QNetworkReply::setSslConfigurationImplementation(const QSslConfiguration& arg__1) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setSslConfigurationImplementation"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"" , "const QSslConfiguration&"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| void* args[2] = {NULL, (void*)&arg__1}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return; | ||||
| } | ||||
| } | ||||
| QNetworkReply::setSslConfigurationImplementation(arg__1); | ||||
| } | ||||
| qint64 PythonQtShell_QNetworkReply::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 QNetworkReply::size(); | ||||
| } | ||||
| void PythonQtShell_QNetworkReply::sslConfigurationImplementation(QSslConfiguration& arg__1) const | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "sslConfigurationImplementation"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"" , "QSslConfiguration&"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| void* args[2] = {NULL, (void*)&arg__1}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return; | ||||
| } | ||||
| } | ||||
| QNetworkReply::sslConfigurationImplementation(arg__1); | ||||
| } | ||||
| void PythonQtShell_QNetworkReply::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; | ||||
| } | ||||
| } | ||||
| QNetworkReply::timerEvent(arg__1); | ||||
| } | ||||
| bool PythonQtShell_QNetworkReply::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 QNetworkReply::waitForBytesWritten(msecs); | ||||
| } | ||||
| bool PythonQtShell_QNetworkReply::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 QNetworkReply::waitForReadyRead(msecs); | ||||
| } | ||||
| qint64 PythonQtShell_QNetworkReply::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 QNetworkReply::writeData(data, len); | ||||
| } | ||||
| QVariant PythonQtWrapper_QNetworkReply::attribute(QNetworkReply* theWrappedObject, QNetworkRequest::Attribute code) const | ||||
| { | ||||
| return ( theWrappedObject->attribute(code)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkReply::close(QNetworkReply* theWrappedObject) | ||||
| { | ||||
| ( ((PythonQtPublicPromoter_QNetworkReply*)theWrappedObject)->promoted_close()); | ||||
| } | ||||
| QNetworkReply::NetworkError PythonQtWrapper_QNetworkReply::error(QNetworkReply* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->error()); | ||||
| } | ||||
| bool PythonQtWrapper_QNetworkReply::hasRawHeader(QNetworkReply* theWrappedObject, const QByteArray& headerName) const | ||||
| { | ||||
| return ( theWrappedObject->hasRawHeader(headerName)); | ||||
| } | ||||
| QVariant PythonQtWrapper_QNetworkReply::header(QNetworkReply* theWrappedObject, QNetworkRequest::KnownHeaders header) const | ||||
| { | ||||
| return ( theWrappedObject->header(header)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkReply::ignoreSslErrors(QNetworkReply* theWrappedObject) | ||||
| { | ||||
| ( ((PythonQtPublicPromoter_QNetworkReply*)theWrappedObject)->promoted_ignoreSslErrors()); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkReply::ignoreSslErrors(QNetworkReply* theWrappedObject, const QList<QSslError >& errors) | ||||
| { | ||||
| ( theWrappedObject->ignoreSslErrors(errors)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkReply::ignoreSslErrorsImplementation(QNetworkReply* theWrappedObject, const QList<QSslError >& arg__1) | ||||
| { | ||||
| ( ((PythonQtPublicPromoter_QNetworkReply*)theWrappedObject)->promoted_ignoreSslErrorsImplementation(arg__1)); | ||||
| } | ||||
| bool PythonQtWrapper_QNetworkReply::isFinished(QNetworkReply* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->isFinished()); | ||||
| } | ||||
| bool PythonQtWrapper_QNetworkReply::isRunning(QNetworkReply* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->isRunning()); | ||||
| } | ||||
| bool PythonQtWrapper_QNetworkReply::isSequential(QNetworkReply* theWrappedObject) const | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QNetworkReply*)theWrappedObject)->promoted_isSequential()); | ||||
| } | ||||
| QNetworkAccessManager* PythonQtWrapper_QNetworkReply::manager(QNetworkReply* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->manager()); | ||||
| } | ||||
| QNetworkAccessManager::Operation PythonQtWrapper_QNetworkReply::operation(QNetworkReply* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->operation()); | ||||
| } | ||||
| QByteArray PythonQtWrapper_QNetworkReply::rawHeader(QNetworkReply* theWrappedObject, const QByteArray& headerName) const | ||||
| { | ||||
| return ( theWrappedObject->rawHeader(headerName)); | ||||
| } | ||||
| QList<QByteArray > PythonQtWrapper_QNetworkReply::rawHeaderList(QNetworkReply* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->rawHeaderList()); | ||||
| } | ||||
| const QList<QPair<QByteArray , QByteArray > >* PythonQtWrapper_QNetworkReply::rawHeaderPairs(QNetworkReply* theWrappedObject) const | ||||
| { | ||||
| return &( theWrappedObject->rawHeaderPairs()); | ||||
| } | ||||
| qint64 PythonQtWrapper_QNetworkReply::readBufferSize(QNetworkReply* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->readBufferSize()); | ||||
| } | ||||
| QNetworkRequest PythonQtWrapper_QNetworkReply::request(QNetworkReply* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->request()); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkReply::setReadBufferSize(QNetworkReply* theWrappedObject, qint64 size) | ||||
| { | ||||
| ( ((PythonQtPublicPromoter_QNetworkReply*)theWrappedObject)->promoted_setReadBufferSize(size)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkReply::setSslConfiguration(QNetworkReply* theWrappedObject, const QSslConfiguration& configuration) | ||||
| { | ||||
| ( theWrappedObject->setSslConfiguration(configuration)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkReply::setSslConfigurationImplementation(QNetworkReply* theWrappedObject, const QSslConfiguration& arg__1) | ||||
| { | ||||
| ( ((PythonQtPublicPromoter_QNetworkReply*)theWrappedObject)->promoted_setSslConfigurationImplementation(arg__1)); | ||||
| } | ||||
| QSslConfiguration PythonQtWrapper_QNetworkReply::sslConfiguration(QNetworkReply* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->sslConfiguration()); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkReply::sslConfigurationImplementation(QNetworkReply* theWrappedObject, QSslConfiguration& arg__1) const | ||||
| { | ||||
| ( ((PythonQtPublicPromoter_QNetworkReply*)theWrappedObject)->promoted_sslConfigurationImplementation(arg__1)); | ||||
| } | ||||
| QUrl PythonQtWrapper_QNetworkReply::url(QNetworkReply* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->url()); | ||||
| } | ||||
| qint64 PythonQtWrapper_QNetworkReply::writeData(QNetworkReply* theWrappedObject, const char* data, qint64 len) | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QNetworkReply*)theWrappedObject)->promoted_writeData(data, len)); | ||||
| } | ||||
| QNetworkRequest* PythonQtWrapper_QNetworkRequest::new_QNetworkRequest(const QNetworkRequest& other) | ||||
| { | ||||
| return new QNetworkRequest(other); } | ||||
| QNetworkRequest* PythonQtWrapper_QNetworkRequest::new_QNetworkRequest(const QUrl& url) | ||||
| { | ||||
| return new QNetworkRequest(url); } | ||||
| QVariant PythonQtWrapper_QNetworkRequest::attribute(QNetworkRequest* theWrappedObject, QNetworkRequest::Attribute code, const QVariant& defaultValue) const | ||||
| { | ||||
| return ( theWrappedObject->attribute(code, defaultValue)); | ||||
| } | ||||
| bool PythonQtWrapper_QNetworkRequest::hasRawHeader(QNetworkRequest* theWrappedObject, const QByteArray& headerName) const | ||||
| { | ||||
| return ( theWrappedObject->hasRawHeader(headerName)); | ||||
| } | ||||
| QVariant PythonQtWrapper_QNetworkRequest::header(QNetworkRequest* theWrappedObject, QNetworkRequest::KnownHeaders header) const | ||||
| { | ||||
| return ( theWrappedObject->header(header)); | ||||
| } | ||||
| bool PythonQtWrapper_QNetworkRequest::__ne__(QNetworkRequest* theWrappedObject, const QNetworkRequest& other) const | ||||
| { | ||||
| return ( (*theWrappedObject)!= other); | ||||
| } | ||||
| bool PythonQtWrapper_QNetworkRequest::__eq__(QNetworkRequest* theWrappedObject, const QNetworkRequest& other) const | ||||
| { | ||||
| return ( (*theWrappedObject)== other); | ||||
| } | ||||
| QObject* PythonQtWrapper_QNetworkRequest::originatingObject(QNetworkRequest* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->originatingObject()); | ||||
| } | ||||
| QNetworkRequest::Priority PythonQtWrapper_QNetworkRequest::priority(QNetworkRequest* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->priority()); | ||||
| } | ||||
| QByteArray PythonQtWrapper_QNetworkRequest::rawHeader(QNetworkRequest* theWrappedObject, const QByteArray& headerName) const | ||||
| { | ||||
| return ( theWrappedObject->rawHeader(headerName)); | ||||
| } | ||||
| QList<QByteArray > PythonQtWrapper_QNetworkRequest::rawHeaderList(QNetworkRequest* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->rawHeaderList()); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkRequest::setAttribute(QNetworkRequest* theWrappedObject, QNetworkRequest::Attribute code, const QVariant& value) | ||||
| { | ||||
| ( theWrappedObject->setAttribute(code, value)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkRequest::setHeader(QNetworkRequest* theWrappedObject, QNetworkRequest::KnownHeaders header, const QVariant& value) | ||||
| { | ||||
| ( theWrappedObject->setHeader(header, value)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkRequest::setOriginatingObject(QNetworkRequest* theWrappedObject, QObject* object) | ||||
| { | ||||
| ( theWrappedObject->setOriginatingObject(object)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkRequest::setPriority(QNetworkRequest* theWrappedObject, QNetworkRequest::Priority priority) | ||||
| { | ||||
| ( theWrappedObject->setPriority(priority)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkRequest::setRawHeader(QNetworkRequest* theWrappedObject, const QByteArray& headerName, const QByteArray& value) | ||||
| { | ||||
| ( theWrappedObject->setRawHeader(headerName, value)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkRequest::setSslConfiguration(QNetworkRequest* theWrappedObject, const QSslConfiguration& configuration) | ||||
| { | ||||
| ( theWrappedObject->setSslConfiguration(configuration)); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkRequest::setUrl(QNetworkRequest* theWrappedObject, const QUrl& url) | ||||
| { | ||||
| ( theWrappedObject->setUrl(url)); | ||||
| } | ||||
| QSslConfiguration PythonQtWrapper_QNetworkRequest::sslConfiguration(QNetworkRequest* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->sslConfiguration()); | ||||
| } | ||||
| void PythonQtWrapper_QNetworkRequest::swap(QNetworkRequest* theWrappedObject, QNetworkRequest& other) | ||||
| { | ||||
| ( theWrappedObject->swap(other)); | ||||
| } | ||||
| QUrl PythonQtWrapper_QNetworkRequest::url(QNetworkRequest* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->url()); | ||||
| } | ||||
| QSslCertificate* PythonQtWrapper_QSslCertificate::new_QSslCertificate(QIODevice* device, QSsl::EncodingFormat format) | ||||
| { | ||||
| return new QSslCertificate(device, format); } | ||||
| QSslCertificate* PythonQtWrapper_QSslCertificate::new_QSslCertificate(const QByteArray& data, QSsl::EncodingFormat format) | ||||
| { | ||||
| return new QSslCertificate(data, format); } | ||||
| QSslCertificate* PythonQtWrapper_QSslCertificate::new_QSslCertificate(const QSslCertificate& other) | ||||
| { | ||||
| return new QSslCertificate(other); } | ||||
| void PythonQtWrapper_QSslCertificate::clear(QSslCertificate* theWrappedObject) | ||||
| { | ||||
| ( theWrappedObject->clear()); | ||||
| } | ||||
| QByteArray PythonQtWrapper_QSslCertificate::digest(QSslCertificate* theWrappedObject, QCryptographicHash::Algorithm algorithm) const | ||||
| { | ||||
| return ( theWrappedObject->digest(algorithm)); | ||||
| } | ||||
| QDateTime PythonQtWrapper_QSslCertificate::effectiveDate(QSslCertificate* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->effectiveDate()); | ||||
| } | ||||
| QDateTime PythonQtWrapper_QSslCertificate::expiryDate(QSslCertificate* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->expiryDate()); | ||||
| } | ||||
| QList<QSslCertificate > PythonQtWrapper_QSslCertificate::static_QSslCertificate_fromData(const QByteArray& data, QSsl::EncodingFormat format) | ||||
| { | ||||
| return (QSslCertificate::fromData(data, format)); | ||||
| } | ||||
| QList<QSslCertificate > PythonQtWrapper_QSslCertificate::static_QSslCertificate_fromDevice(QIODevice* device, QSsl::EncodingFormat format) | ||||
| { | ||||
| return (QSslCertificate::fromDevice(device, format)); | ||||
| } | ||||
| QList<QSslCertificate > PythonQtWrapper_QSslCertificate::static_QSslCertificate_fromPath(const QString& path, QSsl::EncodingFormat format, QRegExp::PatternSyntax syntax) | ||||
| { | ||||
| return (QSslCertificate::fromPath(path, format, syntax)); | ||||
| } | ||||
| Qt::HANDLE PythonQtWrapper_QSslCertificate::handle(QSslCertificate* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->handle()); | ||||
| } | ||||
| bool PythonQtWrapper_QSslCertificate::isBlacklisted(QSslCertificate* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->isBlacklisted()); | ||||
| } | ||||
| bool PythonQtWrapper_QSslCertificate::isNull(QSslCertificate* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->isNull()); | ||||
| } | ||||
| QStringList PythonQtWrapper_QSslCertificate::issuerInfo(QSslCertificate* theWrappedObject, QSslCertificate::SubjectInfo info) const | ||||
| { | ||||
| return ( theWrappedObject->issuerInfo(info)); | ||||
| } | ||||
| QStringList PythonQtWrapper_QSslCertificate::issuerInfo(QSslCertificate* theWrappedObject, const QByteArray& attribute) const | ||||
| { | ||||
| return ( theWrappedObject->issuerInfo(attribute)); | ||||
| } | ||||
| QList<QByteArray > PythonQtWrapper_QSslCertificate::issuerInfoAttributes(QSslCertificate* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->issuerInfoAttributes()); | ||||
| } | ||||
| bool PythonQtWrapper_QSslCertificate::__ne__(QSslCertificate* theWrappedObject, const QSslCertificate& other) const | ||||
| { | ||||
| return ( (*theWrappedObject)!= other); | ||||
| } | ||||
| QSslCertificate* PythonQtWrapper_QSslCertificate::operator_assign(QSslCertificate* theWrappedObject, const QSslCertificate& other) | ||||
| { | ||||
| return &( (*theWrappedObject)= other); | ||||
| } | ||||
| bool PythonQtWrapper_QSslCertificate::__eq__(QSslCertificate* theWrappedObject, const QSslCertificate& other) const | ||||
| { | ||||
| return ( (*theWrappedObject)== other); | ||||
| } | ||||
| QSslKey PythonQtWrapper_QSslCertificate::publicKey(QSslCertificate* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->publicKey()); | ||||
| } | ||||
| QByteArray PythonQtWrapper_QSslCertificate::serialNumber(QSslCertificate* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->serialNumber()); | ||||
| } | ||||
| QStringList PythonQtWrapper_QSslCertificate::subjectInfo(QSslCertificate* theWrappedObject, QSslCertificate::SubjectInfo info) const | ||||
| { | ||||
| return ( theWrappedObject->subjectInfo(info)); | ||||
| } | ||||
| QStringList PythonQtWrapper_QSslCertificate::subjectInfo(QSslCertificate* theWrappedObject, const QByteArray& attribute) const | ||||
| { | ||||
| return ( theWrappedObject->subjectInfo(attribute)); | ||||
| } | ||||
| QList<QByteArray > PythonQtWrapper_QSslCertificate::subjectInfoAttributes(QSslCertificate* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->subjectInfoAttributes()); | ||||
| } | ||||
| void PythonQtWrapper_QSslCertificate::swap(QSslCertificate* theWrappedObject, QSslCertificate& other) | ||||
| { | ||||
| ( theWrappedObject->swap(other)); | ||||
| } | ||||
| QByteArray PythonQtWrapper_QSslCertificate::toDer(QSslCertificate* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->toDer()); | ||||
| } | ||||
| QByteArray PythonQtWrapper_QSslCertificate::toPem(QSslCertificate* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->toPem()); | ||||
| } | ||||
| QString PythonQtWrapper_QSslCertificate::toText(QSslCertificate* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->toText()); | ||||
| } | ||||
| QList<QSslError > PythonQtWrapper_QSslCertificate::static_QSslCertificate_verify(QList<QSslCertificate > certificateChain, const QString& hostName) | ||||
| { | ||||
| return (QSslCertificate::verify(certificateChain, hostName)); | ||||
| } | ||||
| QByteArray PythonQtWrapper_QSslCertificate::version(QSslCertificate* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->version()); | ||||
| } | ||||
| QString PythonQtWrapper_QSslCertificate::py_toString(QSslCertificate* obj) { | ||||
| QString result; | ||||
| QDebug d(&result); | ||||
| d << *obj; | ||||
| return result; | ||||
| } | ||||
| QSslCipher* PythonQtWrapper_QSslCipher::new_QSslCipher() | ||||
| { | ||||
| return new QSslCipher(); } | ||||
| QSslCipher* PythonQtWrapper_QSslCipher::new_QSslCipher(const QSslCipher& other) | ||||
| { | ||||
| return new QSslCipher(other); } | ||||
| QSslCipher* PythonQtWrapper_QSslCipher::new_QSslCipher(const QString& name, QSsl::SslProtocol protocol) | ||||
| { | ||||
| return new QSslCipher(name, protocol); } | ||||
| QString PythonQtWrapper_QSslCipher::authenticationMethod(QSslCipher* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->authenticationMethod()); | ||||
| } | ||||
| QString PythonQtWrapper_QSslCipher::encryptionMethod(QSslCipher* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->encryptionMethod()); | ||||
| } | ||||
| bool PythonQtWrapper_QSslCipher::isNull(QSslCipher* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->isNull()); | ||||
| } | ||||
| QString PythonQtWrapper_QSslCipher::keyExchangeMethod(QSslCipher* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->keyExchangeMethod()); | ||||
| } | ||||
| QString PythonQtWrapper_QSslCipher::name(QSslCipher* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->name()); | ||||
| } | ||||
| bool PythonQtWrapper_QSslCipher::__ne__(QSslCipher* theWrappedObject, const QSslCipher& other) const | ||||
| { | ||||
| return ( (*theWrappedObject)!= other); | ||||
| } | ||||
| QSslCipher* PythonQtWrapper_QSslCipher::operator_assign(QSslCipher* theWrappedObject, const QSslCipher& other) | ||||
| { | ||||
| return &( (*theWrappedObject)= other); | ||||
| } | ||||
| bool PythonQtWrapper_QSslCipher::__eq__(QSslCipher* theWrappedObject, const QSslCipher& other) const | ||||
| { | ||||
| return ( (*theWrappedObject)== other); | ||||
| } | ||||
| QSsl::SslProtocol PythonQtWrapper_QSslCipher::protocol(QSslCipher* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->protocol()); | ||||
| } | ||||
| QString PythonQtWrapper_QSslCipher::protocolString(QSslCipher* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->protocolString()); | ||||
| } | ||||
| int PythonQtWrapper_QSslCipher::supportedBits(QSslCipher* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->supportedBits()); | ||||
| } | ||||
| void PythonQtWrapper_QSslCipher::swap(QSslCipher* theWrappedObject, QSslCipher& other) | ||||
| { | ||||
| ( theWrappedObject->swap(other)); | ||||
| } | ||||
| int PythonQtWrapper_QSslCipher::usedBits(QSslCipher* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->usedBits()); | ||||
| } | ||||
| QString PythonQtWrapper_QSslCipher::py_toString(QSslCipher* obj) { | ||||
| QString result; | ||||
| QDebug d(&result); | ||||
| d << *obj; | ||||
| return result; | ||||
| } | ||||
| QSslConfiguration* PythonQtWrapper_QSslConfiguration::new_QSslConfiguration() | ||||
| { | ||||
| return new QSslConfiguration(); } | ||||
| QSslConfiguration* PythonQtWrapper_QSslConfiguration::new_QSslConfiguration(const QSslConfiguration& other) | ||||
| { | ||||
| return new QSslConfiguration(other); } | ||||
| QList<QSslCertificate > PythonQtWrapper_QSslConfiguration::caCertificates(QSslConfiguration* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->caCertificates()); | ||||
| } | ||||
| QList<QSslCipher > PythonQtWrapper_QSslConfiguration::ciphers(QSslConfiguration* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->ciphers()); | ||||
| } | ||||
| QSslConfiguration PythonQtWrapper_QSslConfiguration::static_QSslConfiguration_defaultConfiguration() | ||||
| { | ||||
| return (QSslConfiguration::defaultConfiguration()); | ||||
| } | ||||
| bool PythonQtWrapper_QSslConfiguration::isNull(QSslConfiguration* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->isNull()); | ||||
| } | ||||
| QSslCertificate PythonQtWrapper_QSslConfiguration::localCertificate(QSslConfiguration* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->localCertificate()); | ||||
| } | ||||
| bool PythonQtWrapper_QSslConfiguration::__ne__(QSslConfiguration* theWrappedObject, const QSslConfiguration& other) const | ||||
| { | ||||
| return ( (*theWrappedObject)!= other); | ||||
| } | ||||
| QSslConfiguration* PythonQtWrapper_QSslConfiguration::operator_assign(QSslConfiguration* theWrappedObject, const QSslConfiguration& other) | ||||
| { | ||||
| return &( (*theWrappedObject)= other); | ||||
| } | ||||
| bool PythonQtWrapper_QSslConfiguration::__eq__(QSslConfiguration* theWrappedObject, const QSslConfiguration& other) const | ||||
| { | ||||
| return ( (*theWrappedObject)== other); | ||||
| } | ||||
| QSslCertificate PythonQtWrapper_QSslConfiguration::peerCertificate(QSslConfiguration* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->peerCertificate()); | ||||
| } | ||||
| QList<QSslCertificate > PythonQtWrapper_QSslConfiguration::peerCertificateChain(QSslConfiguration* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->peerCertificateChain()); | ||||
| } | ||||
| int PythonQtWrapper_QSslConfiguration::peerVerifyDepth(QSslConfiguration* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->peerVerifyDepth()); | ||||
| } | ||||
| QSslSocket::PeerVerifyMode PythonQtWrapper_QSslConfiguration::peerVerifyMode(QSslConfiguration* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->peerVerifyMode()); | ||||
| } | ||||
| QSslKey PythonQtWrapper_QSslConfiguration::privateKey(QSslConfiguration* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->privateKey()); | ||||
| } | ||||
| QSsl::SslProtocol PythonQtWrapper_QSslConfiguration::protocol(QSslConfiguration* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->protocol()); | ||||
| } | ||||
| QSslCipher PythonQtWrapper_QSslConfiguration::sessionCipher(QSslConfiguration* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->sessionCipher()); | ||||
| } | ||||
| void PythonQtWrapper_QSslConfiguration::setCaCertificates(QSslConfiguration* theWrappedObject, const QList<QSslCertificate >& certificates) | ||||
| { | ||||
| ( theWrappedObject->setCaCertificates(certificates)); | ||||
| } | ||||
| void PythonQtWrapper_QSslConfiguration::setCiphers(QSslConfiguration* theWrappedObject, const QList<QSslCipher >& ciphers) | ||||
| { | ||||
| ( theWrappedObject->setCiphers(ciphers)); | ||||
| } | ||||
| void PythonQtWrapper_QSslConfiguration::static_QSslConfiguration_setDefaultConfiguration(const QSslConfiguration& configuration) | ||||
| { | ||||
| (QSslConfiguration::setDefaultConfiguration(configuration)); | ||||
| } | ||||
| void PythonQtWrapper_QSslConfiguration::setLocalCertificate(QSslConfiguration* theWrappedObject, const QSslCertificate& certificate) | ||||
| { | ||||
| ( theWrappedObject->setLocalCertificate(certificate)); | ||||
| } | ||||
| void PythonQtWrapper_QSslConfiguration::setPeerVerifyDepth(QSslConfiguration* theWrappedObject, int depth) | ||||
| { | ||||
| ( theWrappedObject->setPeerVerifyDepth(depth)); | ||||
| } | ||||
| void PythonQtWrapper_QSslConfiguration::setPeerVerifyMode(QSslConfiguration* theWrappedObject, QSslSocket::PeerVerifyMode mode) | ||||
| { | ||||
| ( theWrappedObject->setPeerVerifyMode(mode)); | ||||
| } | ||||
| void PythonQtWrapper_QSslConfiguration::setPrivateKey(QSslConfiguration* theWrappedObject, const QSslKey& key) | ||||
| { | ||||
| ( theWrappedObject->setPrivateKey(key)); | ||||
| } | ||||
| void PythonQtWrapper_QSslConfiguration::setProtocol(QSslConfiguration* theWrappedObject, QSsl::SslProtocol protocol) | ||||
| { | ||||
| ( theWrappedObject->setProtocol(protocol)); | ||||
| } | ||||
| void PythonQtWrapper_QSslConfiguration::swap(QSslConfiguration* theWrappedObject, QSslConfiguration& other) | ||||
| { | ||||
| ( theWrappedObject->swap(other)); | ||||
| } | ||||
| QSslError* PythonQtWrapper_QSslError::new_QSslError() | ||||
| { | ||||
| return new QSslError(); } | ||||
| QSslError* PythonQtWrapper_QSslError::new_QSslError(QSslError::SslError error) | ||||
| { | ||||
| return new QSslError(error); } | ||||
| QSslError* PythonQtWrapper_QSslError::new_QSslError(QSslError::SslError error, const QSslCertificate& certificate) | ||||
| { | ||||
| return new QSslError(error, certificate); } | ||||
| QSslError* PythonQtWrapper_QSslError::new_QSslError(const QSslError& other) | ||||
| { | ||||
| return new QSslError(other); } | ||||
| QSslCertificate PythonQtWrapper_QSslError::certificate(QSslError* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->certificate()); | ||||
| } | ||||
| QSslError::SslError PythonQtWrapper_QSslError::error(QSslError* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->error()); | ||||
| } | ||||
| QString PythonQtWrapper_QSslError::errorString(QSslError* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->errorString()); | ||||
| } | ||||
| bool PythonQtWrapper_QSslError::__ne__(QSslError* theWrappedObject, const QSslError& other) const | ||||
| { | ||||
| return ( (*theWrappedObject)!= other); | ||||
| } | ||||
| QSslError* PythonQtWrapper_QSslError::operator_assign(QSslError* theWrappedObject, const QSslError& other) | ||||
| { | ||||
| return &( (*theWrappedObject)= other); | ||||
| } | ||||
| bool PythonQtWrapper_QSslError::__eq__(QSslError* theWrappedObject, const QSslError& other) const | ||||
| { | ||||
| return ( (*theWrappedObject)== other); | ||||
| } | ||||
| void PythonQtWrapper_QSslError::swap(QSslError* theWrappedObject, QSslError& other) | ||||
| { | ||||
| ( theWrappedObject->swap(other)); | ||||
| } | ||||
| QString PythonQtWrapper_QSslError::py_toString(QSslError* obj) { | ||||
| QString result; | ||||
| QDebug d(&result); | ||||
| d << *obj; | ||||
| return result; | ||||
| } | ||||
| QSslKey* PythonQtWrapper_QSslKey::new_QSslKey() | ||||
| { | ||||
| return new QSslKey(); } | ||||
| QSslKey* PythonQtWrapper_QSslKey::new_QSslKey(QIODevice* device, QSsl::KeyAlgorithm algorithm, QSsl::EncodingFormat format, QSsl::KeyType type, const QByteArray& passPhrase) | ||||
| { | ||||
| return new QSslKey(device, algorithm, format, type, passPhrase); } | ||||
| QSslKey* PythonQtWrapper_QSslKey::new_QSslKey(Qt::HANDLE handle, QSsl::KeyType type) | ||||
| { | ||||
| return new QSslKey(handle, type); } | ||||
| QSslKey* PythonQtWrapper_QSslKey::new_QSslKey(const QByteArray& encoded, QSsl::KeyAlgorithm algorithm, QSsl::EncodingFormat format, QSsl::KeyType type, const QByteArray& passPhrase) | ||||
| { | ||||
| return new QSslKey(encoded, algorithm, format, type, passPhrase); } | ||||
| QSslKey* PythonQtWrapper_QSslKey::new_QSslKey(const QSslKey& other) | ||||
| { | ||||
| return new QSslKey(other); } | ||||
| QSsl::KeyAlgorithm PythonQtWrapper_QSslKey::algorithm(QSslKey* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->algorithm()); | ||||
| } | ||||
| void PythonQtWrapper_QSslKey::clear(QSslKey* theWrappedObject) | ||||
| { | ||||
| ( theWrappedObject->clear()); | ||||
| } | ||||
| Qt::HANDLE PythonQtWrapper_QSslKey::handle(QSslKey* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->handle()); | ||||
| } | ||||
| bool PythonQtWrapper_QSslKey::isNull(QSslKey* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->isNull()); | ||||
| } | ||||
| int PythonQtWrapper_QSslKey::length(QSslKey* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->length()); | ||||
| } | ||||
| bool PythonQtWrapper_QSslKey::__ne__(QSslKey* theWrappedObject, const QSslKey& key) const | ||||
| { | ||||
| return ( (*theWrappedObject)!= key); | ||||
| } | ||||
| QSslKey* PythonQtWrapper_QSslKey::operator_assign(QSslKey* theWrappedObject, const QSslKey& other) | ||||
| { | ||||
| return &( (*theWrappedObject)= other); | ||||
| } | ||||
| bool PythonQtWrapper_QSslKey::__eq__(QSslKey* theWrappedObject, const QSslKey& key) const | ||||
| { | ||||
| return ( (*theWrappedObject)== key); | ||||
| } | ||||
| void PythonQtWrapper_QSslKey::swap(QSslKey* theWrappedObject, QSslKey& other) | ||||
| { | ||||
| ( theWrappedObject->swap(other)); | ||||
| } | ||||
| QByteArray PythonQtWrapper_QSslKey::toDer(QSslKey* theWrappedObject, const QByteArray& passPhrase) const | ||||
| { | ||||
| return ( theWrappedObject->toDer(passPhrase)); | ||||
| } | ||||
| QByteArray PythonQtWrapper_QSslKey::toPem(QSslKey* theWrappedObject, const QByteArray& passPhrase) const | ||||
| { | ||||
| return ( theWrappedObject->toPem(passPhrase)); | ||||
| } | ||||
| QSsl::KeyType PythonQtWrapper_QSslKey::type(QSslKey* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->type()); | ||||
| } | ||||
| QString PythonQtWrapper_QSslKey::py_toString(QSslKey* obj) { | ||||
| QString result; | ||||
| QDebug d(&result); | ||||
| d << *obj; | ||||
| return result; | ||||
| } | ||||
| PythonQtShell_QSslSocket::~PythonQtShell_QSslSocket() { | ||||
| PythonQtPrivate* priv = PythonQt::priv(); | ||||
| if (priv) { priv->shellClassDeleted(this); } | ||||
| } | ||||
| bool PythonQtShell_QSslSocket::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 QSslSocket::atEnd(); | ||||
| } | ||||
| qint64 PythonQtShell_QSslSocket::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 QSslSocket::bytesAvailable(); | ||||
| } | ||||
| qint64 PythonQtShell_QSslSocket::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 QSslSocket::bytesToWrite(); | ||||
| } | ||||
| bool PythonQtShell_QSslSocket::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 QSslSocket::canReadLine(); | ||||
| } | ||||
| void PythonQtShell_QSslSocket::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; | ||||
| } | ||||
| } | ||||
| QSslSocket::childEvent(arg__1); | ||||
| } | ||||
| void PythonQtShell_QSslSocket::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; | ||||
| } | ||||
| } | ||||
| QSslSocket::close(); | ||||
| } | ||||
| void PythonQtShell_QSslSocket::connectToHost(const QString& hostName, unsigned short port, QIODevice::OpenMode openMode, QAbstractSocket::NetworkLayerProtocol protocol) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "connectToHost"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"" , "const QString&" , "unsigned short" , "QIODevice::OpenMode" , "QAbstractSocket::NetworkLayerProtocol"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList); | ||||
| void* args[5] = {NULL, (void*)&hostName, (void*)&port, (void*)&openMode, (void*)&protocol}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return; | ||||
| } | ||||
| } | ||||
| QSslSocket::connectToHost(hostName, port, openMode, protocol); | ||||
| } | ||||
| void PythonQtShell_QSslSocket::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; | ||||
| } | ||||
| } | ||||
| QSslSocket::customEvent(arg__1); | ||||
| } | ||||
| void PythonQtShell_QSslSocket::disconnectFromHost() | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "disconnectFromHost"); | ||||
| 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; | ||||
| } | ||||
| } | ||||
| QSslSocket::disconnectFromHost(); | ||||
| } | ||||
| bool PythonQtShell_QSslSocket::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 QSslSocket::event(arg__1); | ||||
| } | ||||
| bool PythonQtShell_QSslSocket::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 QSslSocket::eventFilter(arg__1, arg__2); | ||||
| } | ||||
| bool PythonQtShell_QSslSocket::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 QSslSocket::isSequential(); | ||||
| } | ||||
| bool PythonQtShell_QSslSocket::open(QIODevice::OpenMode mode) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "open"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"bool" , "QIODevice::OpenMode"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| bool returnValue; | ||||
| void* args[2] = {NULL, (void*)&mode}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { | ||||
| args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
| if (args[0]!=&returnValue) { | ||||
| if (args[0]==NULL) { | ||||
| PythonQt::priv()->handleVirtualOverloadReturnError("open", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((bool*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QSslSocket::open(mode); | ||||
| } | ||||
| qint64 PythonQtShell_QSslSocket::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 QSslSocket::pos(); | ||||
| } | ||||
| qint64 PythonQtShell_QSslSocket::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 QSslSocket::readData(data, maxlen); | ||||
| } | ||||
| qint64 PythonQtShell_QSslSocket::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 QSslSocket::readLineData(data, maxlen); | ||||
| } | ||||
| bool PythonQtShell_QSslSocket::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 QSslSocket::reset(); | ||||
| } | ||||
| void PythonQtShell_QSslSocket::resume() | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resume"); | ||||
| 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; | ||||
| } | ||||
| } | ||||
| QSslSocket::resume(); | ||||
| } | ||||
| bool PythonQtShell_QSslSocket::seek(qint64 pos) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "seek"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"bool" , "qint64"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| bool returnValue; | ||||
| void* args[2] = {NULL, (void*)&pos}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { | ||||
| args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
| if (args[0]!=&returnValue) { | ||||
| if (args[0]==NULL) { | ||||
| PythonQt::priv()->handleVirtualOverloadReturnError("seek", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((bool*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QSslSocket::seek(pos); | ||||
| } | ||||
| void PythonQtShell_QSslSocket::setReadBufferSize(qint64 size) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setReadBufferSize"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"" , "qint64"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| void* args[2] = {NULL, (void*)&size}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return; | ||||
| } | ||||
| } | ||||
| QSslSocket::setReadBufferSize(size); | ||||
| } | ||||
| void PythonQtShell_QSslSocket::setSocketOption(QAbstractSocket::SocketOption option, const QVariant& value) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setSocketOption"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"" , "QAbstractSocket::SocketOption" , "const QVariant&"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
| void* args[3] = {NULL, (void*)&option, (void*)&value}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return; | ||||
| } | ||||
| } | ||||
| QSslSocket::setSocketOption(option, value); | ||||
| } | ||||
| qint64 PythonQtShell_QSslSocket::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 QSslSocket::size(); | ||||
| } | ||||
| QVariant PythonQtShell_QSslSocket::socketOption(QAbstractSocket::SocketOption option) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "socketOption"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"QVariant" , "QAbstractSocket::SocketOption"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| QVariant returnValue; | ||||
| void* args[2] = {NULL, (void*)&option}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { | ||||
| args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
| if (args[0]!=&returnValue) { | ||||
| if (args[0]==NULL) { | ||||
| PythonQt::priv()->handleVirtualOverloadReturnError("socketOption", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((QVariant*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QSslSocket::socketOption(option); | ||||
| } | ||||
| void PythonQtShell_QSslSocket::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; | ||||
| } | ||||
| } | ||||
| QSslSocket::timerEvent(arg__1); | ||||
| } | ||||
| bool PythonQtShell_QSslSocket::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 QSslSocket::waitForBytesWritten(msecs); | ||||
| } | ||||
| bool PythonQtShell_QSslSocket::waitForConnected(int msecs) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "waitForConnected"); | ||||
| 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("waitForConnected", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((bool*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QSslSocket::waitForConnected(msecs); | ||||
| } | ||||
| bool PythonQtShell_QSslSocket::waitForDisconnected(int msecs) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "waitForDisconnected"); | ||||
| 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("waitForDisconnected", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((bool*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QSslSocket::waitForDisconnected(msecs); | ||||
| } | ||||
| bool PythonQtShell_QSslSocket::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 QSslSocket::waitForReadyRead(msecs); | ||||
| } | ||||
| qint64 PythonQtShell_QSslSocket::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 QSslSocket::writeData(data, len); | ||||
| } | ||||
| QSslSocket* PythonQtWrapper_QSslSocket::new_QSslSocket(QObject* parent) | ||||
| { | ||||
| return new PythonQtShell_QSslSocket(parent); } | ||||
| void PythonQtWrapper_QSslSocket::abort(QSslSocket* theWrappedObject) | ||||
| { | ||||
| ( theWrappedObject->abort()); | ||||
| } | ||||
| void PythonQtWrapper_QSslSocket::addCaCertificate(QSslSocket* theWrappedObject, const QSslCertificate& certificate) | ||||
| { | ||||
| ( theWrappedObject->addCaCertificate(certificate)); | ||||
| } | ||||
| void PythonQtWrapper_QSslSocket::addCaCertificates(QSslSocket* theWrappedObject, const QList<QSslCertificate >& certificates) | ||||
| { | ||||
| ( theWrappedObject->addCaCertificates(certificates)); | ||||
| } | ||||
| bool PythonQtWrapper_QSslSocket::addCaCertificates(QSslSocket* theWrappedObject, const QString& path, QSsl::EncodingFormat format, QRegExp::PatternSyntax syntax) | ||||
| { | ||||
| return ( theWrappedObject->addCaCertificates(path, format, syntax)); | ||||
| } | ||||
| void PythonQtWrapper_QSslSocket::static_QSslSocket_addDefaultCaCertificate(const QSslCertificate& certificate) | ||||
| { | ||||
| (QSslSocket::addDefaultCaCertificate(certificate)); | ||||
| } | ||||
| void PythonQtWrapper_QSslSocket::static_QSslSocket_addDefaultCaCertificates(const QList<QSslCertificate >& certificates) | ||||
| { | ||||
| (QSslSocket::addDefaultCaCertificates(certificates)); | ||||
| } | ||||
| bool PythonQtWrapper_QSslSocket::static_QSslSocket_addDefaultCaCertificates(const QString& path, QSsl::EncodingFormat format, QRegExp::PatternSyntax syntax) | ||||
| { | ||||
| return (QSslSocket::addDefaultCaCertificates(path, format, syntax)); | ||||
| } | ||||
| bool PythonQtWrapper_QSslSocket::atEnd(QSslSocket* theWrappedObject) const | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_atEnd()); | ||||
| } | ||||
| qint64 PythonQtWrapper_QSslSocket::bytesAvailable(QSslSocket* theWrappedObject) const | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_bytesAvailable()); | ||||
| } | ||||
| qint64 PythonQtWrapper_QSslSocket::bytesToWrite(QSslSocket* theWrappedObject) const | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_bytesToWrite()); | ||||
| } | ||||
| QList<QSslCertificate > PythonQtWrapper_QSslSocket::caCertificates(QSslSocket* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->caCertificates()); | ||||
| } | ||||
| bool PythonQtWrapper_QSslSocket::canReadLine(QSslSocket* theWrappedObject) const | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_canReadLine()); | ||||
| } | ||||
| QList<QSslCipher > PythonQtWrapper_QSslSocket::ciphers(QSslSocket* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->ciphers()); | ||||
| } | ||||
| void PythonQtWrapper_QSslSocket::close(QSslSocket* theWrappedObject) | ||||
| { | ||||
| ( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_close()); | ||||
| } | ||||
| void PythonQtWrapper_QSslSocket::connectToHost(QSslSocket* theWrappedObject, const QString& hostName, unsigned short port, QIODevice::OpenMode openMode, QAbstractSocket::NetworkLayerProtocol protocol) | ||||
| { | ||||
| ( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_connectToHost(hostName, port, openMode, protocol)); | ||||
| } | ||||
| void PythonQtWrapper_QSslSocket::connectToHostEncrypted(QSslSocket* theWrappedObject, const QString& hostName, unsigned short port, QIODevice::OpenMode mode, QAbstractSocket::NetworkLayerProtocol protocol) | ||||
| { | ||||
| ( theWrappedObject->connectToHostEncrypted(hostName, port, mode, protocol)); | ||||
| } | ||||
| void PythonQtWrapper_QSslSocket::connectToHostEncrypted(QSslSocket* theWrappedObject, const QString& hostName, unsigned short port, const QString& sslPeerName, QIODevice::OpenMode mode, QAbstractSocket::NetworkLayerProtocol protocol) | ||||
| { | ||||
| ( theWrappedObject->connectToHostEncrypted(hostName, port, sslPeerName, mode, protocol)); | ||||
| } | ||||
| QList<QSslCertificate > PythonQtWrapper_QSslSocket::static_QSslSocket_defaultCaCertificates() | ||||
| { | ||||
| return (QSslSocket::defaultCaCertificates()); | ||||
| } | ||||
| QList<QSslCipher > PythonQtWrapper_QSslSocket::static_QSslSocket_defaultCiphers() | ||||
| { | ||||
| return (QSslSocket::defaultCiphers()); | ||||
| } | ||||
| void PythonQtWrapper_QSslSocket::disconnectFromHost(QSslSocket* theWrappedObject) | ||||
| { | ||||
| ( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_disconnectFromHost()); | ||||
| } | ||||
| qint64 PythonQtWrapper_QSslSocket::encryptedBytesAvailable(QSslSocket* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->encryptedBytesAvailable()); | ||||
| } | ||||
| qint64 PythonQtWrapper_QSslSocket::encryptedBytesToWrite(QSslSocket* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->encryptedBytesToWrite()); | ||||
| } | ||||
| bool PythonQtWrapper_QSslSocket::flush(QSslSocket* theWrappedObject) | ||||
| { | ||||
| return ( theWrappedObject->flush()); | ||||
| } | ||||
| void PythonQtWrapper_QSslSocket::ignoreSslErrors(QSslSocket* theWrappedObject, const QList<QSslError >& errors) | ||||
| { | ||||
| ( theWrappedObject->ignoreSslErrors(errors)); | ||||
| } | ||||
| bool PythonQtWrapper_QSslSocket::isEncrypted(QSslSocket* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->isEncrypted()); | ||||
| } | ||||
| QSslCertificate PythonQtWrapper_QSslSocket::localCertificate(QSslSocket* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->localCertificate()); | ||||
| } | ||||
| QSslSocket::SslMode PythonQtWrapper_QSslSocket::mode(QSslSocket* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->mode()); | ||||
| } | ||||
| QSslCertificate PythonQtWrapper_QSslSocket::peerCertificate(QSslSocket* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->peerCertificate()); | ||||
| } | ||||
| QList<QSslCertificate > PythonQtWrapper_QSslSocket::peerCertificateChain(QSslSocket* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->peerCertificateChain()); | ||||
| } | ||||
| int PythonQtWrapper_QSslSocket::peerVerifyDepth(QSslSocket* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->peerVerifyDepth()); | ||||
| } | ||||
| QSslSocket::PeerVerifyMode PythonQtWrapper_QSslSocket::peerVerifyMode(QSslSocket* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->peerVerifyMode()); | ||||
| } | ||||
| QString PythonQtWrapper_QSslSocket::peerVerifyName(QSslSocket* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->peerVerifyName()); | ||||
| } | ||||
| QSslKey PythonQtWrapper_QSslSocket::privateKey(QSslSocket* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->privateKey()); | ||||
| } | ||||
| QSsl::SslProtocol PythonQtWrapper_QSslSocket::protocol(QSslSocket* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->protocol()); | ||||
| } | ||||
| qint64 PythonQtWrapper_QSslSocket::readData(QSslSocket* theWrappedObject, char* data, qint64 maxlen) | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_readData(data, maxlen)); | ||||
| } | ||||
| void PythonQtWrapper_QSslSocket::resume(QSslSocket* theWrappedObject) | ||||
| { | ||||
| ( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_resume()); | ||||
| } | ||||
| QSslCipher PythonQtWrapper_QSslSocket::sessionCipher(QSslSocket* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->sessionCipher()); | ||||
| } | ||||
| void PythonQtWrapper_QSslSocket::setCaCertificates(QSslSocket* theWrappedObject, const QList<QSslCertificate >& certificates) | ||||
| { | ||||
| ( theWrappedObject->setCaCertificates(certificates)); | ||||
| } | ||||
| void PythonQtWrapper_QSslSocket::setCiphers(QSslSocket* theWrappedObject, const QList<QSslCipher >& ciphers) | ||||
| { | ||||
| ( theWrappedObject->setCiphers(ciphers)); | ||||
| } | ||||
| void PythonQtWrapper_QSslSocket::setCiphers(QSslSocket* theWrappedObject, const QString& ciphers) | ||||
| { | ||||
| ( theWrappedObject->setCiphers(ciphers)); | ||||
| } | ||||
| void PythonQtWrapper_QSslSocket::static_QSslSocket_setDefaultCaCertificates(const QList<QSslCertificate >& certificates) | ||||
| { | ||||
| (QSslSocket::setDefaultCaCertificates(certificates)); | ||||
| } | ||||
| void PythonQtWrapper_QSslSocket::static_QSslSocket_setDefaultCiphers(const QList<QSslCipher >& ciphers) | ||||
| { | ||||
| (QSslSocket::setDefaultCiphers(ciphers)); | ||||
| } | ||||
| void PythonQtWrapper_QSslSocket::setLocalCertificate(QSslSocket* theWrappedObject, const QSslCertificate& certificate) | ||||
| { | ||||
| ( theWrappedObject->setLocalCertificate(certificate)); | ||||
| } | ||||
| void PythonQtWrapper_QSslSocket::setLocalCertificate(QSslSocket* theWrappedObject, const QString& fileName, QSsl::EncodingFormat format) | ||||
| { | ||||
| ( theWrappedObject->setLocalCertificate(fileName, format)); | ||||
| } | ||||
| void PythonQtWrapper_QSslSocket::setPeerVerifyDepth(QSslSocket* theWrappedObject, int depth) | ||||
| { | ||||
| ( theWrappedObject->setPeerVerifyDepth(depth)); | ||||
| } | ||||
| void PythonQtWrapper_QSslSocket::setPeerVerifyMode(QSslSocket* theWrappedObject, QSslSocket::PeerVerifyMode mode) | ||||
| { | ||||
| ( theWrappedObject->setPeerVerifyMode(mode)); | ||||
| } | ||||
| void PythonQtWrapper_QSslSocket::setPeerVerifyName(QSslSocket* theWrappedObject, const QString& hostName) | ||||
| { | ||||
| ( theWrappedObject->setPeerVerifyName(hostName)); | ||||
| } | ||||
| void PythonQtWrapper_QSslSocket::setPrivateKey(QSslSocket* theWrappedObject, const QSslKey& key) | ||||
| { | ||||
| ( theWrappedObject->setPrivateKey(key)); | ||||
| } | ||||
| void PythonQtWrapper_QSslSocket::setPrivateKey(QSslSocket* theWrappedObject, const QString& fileName, QSsl::KeyAlgorithm algorithm, QSsl::EncodingFormat format, const QByteArray& passPhrase) | ||||
| { | ||||
| ( theWrappedObject->setPrivateKey(fileName, algorithm, format, passPhrase)); | ||||
| } | ||||
| void PythonQtWrapper_QSslSocket::setProtocol(QSslSocket* theWrappedObject, QSsl::SslProtocol protocol) | ||||
| { | ||||
| ( theWrappedObject->setProtocol(protocol)); | ||||
| } | ||||
| void PythonQtWrapper_QSslSocket::setReadBufferSize(QSslSocket* theWrappedObject, qint64 size) | ||||
| { | ||||
| ( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_setReadBufferSize(size)); | ||||
| } | ||||
| void PythonQtWrapper_QSslSocket::setSocketOption(QSslSocket* theWrappedObject, QAbstractSocket::SocketOption option, const QVariant& value) | ||||
| { | ||||
| ( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_setSocketOption(option, value)); | ||||
| } | ||||
| void PythonQtWrapper_QSslSocket::setSslConfiguration(QSslSocket* theWrappedObject, const QSslConfiguration& config) | ||||
| { | ||||
| ( theWrappedObject->setSslConfiguration(config)); | ||||
| } | ||||
| QVariant PythonQtWrapper_QSslSocket::socketOption(QSslSocket* theWrappedObject, QAbstractSocket::SocketOption option) | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_socketOption(option)); | ||||
| } | ||||
| QSslConfiguration PythonQtWrapper_QSslSocket::sslConfiguration(QSslSocket* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->sslConfiguration()); | ||||
| } | ||||
| QList<QSslError > PythonQtWrapper_QSslSocket::sslErrors(QSslSocket* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->sslErrors()); | ||||
| } | ||||
| long PythonQtWrapper_QSslSocket::static_QSslSocket_sslLibraryVersionNumber() | ||||
| { | ||||
| return (QSslSocket::sslLibraryVersionNumber()); | ||||
| } | ||||
| QString PythonQtWrapper_QSslSocket::static_QSslSocket_sslLibraryVersionString() | ||||
| { | ||||
| return (QSslSocket::sslLibraryVersionString()); | ||||
| } | ||||
| QList<QSslCipher > PythonQtWrapper_QSslSocket::static_QSslSocket_supportedCiphers() | ||||
| { | ||||
| return (QSslSocket::supportedCiphers()); | ||||
| } | ||||
| bool PythonQtWrapper_QSslSocket::static_QSslSocket_supportsSsl() | ||||
| { | ||||
| return (QSslSocket::supportsSsl()); | ||||
| } | ||||
| QList<QSslCertificate > PythonQtWrapper_QSslSocket::static_QSslSocket_systemCaCertificates() | ||||
| { | ||||
| return (QSslSocket::systemCaCertificates()); | ||||
| } | ||||
| bool PythonQtWrapper_QSslSocket::waitForBytesWritten(QSslSocket* theWrappedObject, int msecs) | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_waitForBytesWritten(msecs)); | ||||
| } | ||||
| bool PythonQtWrapper_QSslSocket::waitForConnected(QSslSocket* theWrappedObject, int msecs) | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_waitForConnected(msecs)); | ||||
| } | ||||
| bool PythonQtWrapper_QSslSocket::waitForDisconnected(QSslSocket* theWrappedObject, int msecs) | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_waitForDisconnected(msecs)); | ||||
| } | ||||
| bool PythonQtWrapper_QSslSocket::waitForEncrypted(QSslSocket* theWrappedObject, int msecs) | ||||
| { | ||||
| return ( theWrappedObject->waitForEncrypted(msecs)); | ||||
| } | ||||
| bool PythonQtWrapper_QSslSocket::waitForReadyRead(QSslSocket* theWrappedObject, int msecs) | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_waitForReadyRead(msecs)); | ||||
| } | ||||
| qint64 PythonQtWrapper_QSslSocket::writeData(QSslSocket* theWrappedObject, const char* data, qint64 len) | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_writeData(data, len)); | ||||
| } | ||||
| PythonQtShell_QTcpServer::~PythonQtShell_QTcpServer() { | ||||
| PythonQtPrivate* priv = PythonQt::priv(); | ||||
| if (priv) { priv->shellClassDeleted(this); } | ||||
| } | ||||
| void PythonQtShell_QTcpServer::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; | ||||
| } | ||||
| } | ||||
| QTcpServer::childEvent(arg__1); | ||||
| } | ||||
| void PythonQtShell_QTcpServer::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; | ||||
| } | ||||
| } | ||||
| QTcpServer::customEvent(arg__1); | ||||
| } | ||||
| bool PythonQtShell_QTcpServer::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 QTcpServer::event(arg__1); | ||||
| } | ||||
| bool PythonQtShell_QTcpServer::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 QTcpServer::eventFilter(arg__1, arg__2); | ||||
| } | ||||
| bool PythonQtShell_QTcpServer::hasPendingConnections() const | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasPendingConnections"); | ||||
| 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("hasPendingConnections", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((bool*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QTcpServer::hasPendingConnections(); | ||||
| } | ||||
| QTcpSocket* PythonQtShell_QTcpServer::nextPendingConnection() | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nextPendingConnection"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"QTcpSocket*"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
| QTcpSocket* 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("nextPendingConnection", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((QTcpSocket**)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QTcpServer::nextPendingConnection(); | ||||
| } | ||||
| void PythonQtShell_QTcpServer::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; | ||||
| } | ||||
| } | ||||
| QTcpServer::timerEvent(arg__1); | ||||
| } | ||||
| QTcpServer* PythonQtWrapper_QTcpServer::new_QTcpServer(QObject* parent) | ||||
| { | ||||
| return new PythonQtShell_QTcpServer(parent); } | ||||
| void PythonQtWrapper_QTcpServer::close(QTcpServer* theWrappedObject) | ||||
| { | ||||
| ( theWrappedObject->close()); | ||||
| } | ||||
| QString PythonQtWrapper_QTcpServer::errorString(QTcpServer* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->errorString()); | ||||
| } | ||||
| bool PythonQtWrapper_QTcpServer::hasPendingConnections(QTcpServer* theWrappedObject) const | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QTcpServer*)theWrappedObject)->promoted_hasPendingConnections()); | ||||
| } | ||||
| bool PythonQtWrapper_QTcpServer::isListening(QTcpServer* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->isListening()); | ||||
| } | ||||
| bool PythonQtWrapper_QTcpServer::listen(QTcpServer* theWrappedObject, const QHostAddress& address, unsigned short port) | ||||
| { | ||||
| return ( theWrappedObject->listen(address, port)); | ||||
| } | ||||
| int PythonQtWrapper_QTcpServer::maxPendingConnections(QTcpServer* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->maxPendingConnections()); | ||||
| } | ||||
| QTcpSocket* PythonQtWrapper_QTcpServer::nextPendingConnection(QTcpServer* theWrappedObject) | ||||
| { | ||||
| return ( ((PythonQtPublicPromoter_QTcpServer*)theWrappedObject)->promoted_nextPendingConnection()); | ||||
| } | ||||
| void PythonQtWrapper_QTcpServer::pauseAccepting(QTcpServer* theWrappedObject) | ||||
| { | ||||
| ( theWrappedObject->pauseAccepting()); | ||||
| } | ||||
| QNetworkProxy PythonQtWrapper_QTcpServer::proxy(QTcpServer* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->proxy()); | ||||
| } | ||||
| void PythonQtWrapper_QTcpServer::resumeAccepting(QTcpServer* theWrappedObject) | ||||
| { | ||||
| ( theWrappedObject->resumeAccepting()); | ||||
| } | ||||
| QHostAddress PythonQtWrapper_QTcpServer::serverAddress(QTcpServer* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->serverAddress()); | ||||
| } | ||||
| QAbstractSocket::SocketError PythonQtWrapper_QTcpServer::serverError(QTcpServer* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->serverError()); | ||||
| } | ||||
| unsigned short PythonQtWrapper_QTcpServer::serverPort(QTcpServer* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->serverPort()); | ||||
| } | ||||
| void PythonQtWrapper_QTcpServer::setMaxPendingConnections(QTcpServer* theWrappedObject, int numConnections) | ||||
| { | ||||
| ( theWrappedObject->setMaxPendingConnections(numConnections)); | ||||
| } | ||||
| void PythonQtWrapper_QTcpServer::setProxy(QTcpServer* theWrappedObject, const QNetworkProxy& networkProxy) | ||||
| { | ||||
| ( theWrappedObject->setProxy(networkProxy)); | ||||
| } | ||||
| bool PythonQtWrapper_QTcpServer::waitForNewConnection(QTcpServer* theWrappedObject, int msec, bool* timedOut) | ||||
| { | ||||
| return ( theWrappedObject->waitForNewConnection(msec, timedOut)); | ||||
| } | ||||
| PythonQtShell_QTcpSocket::~PythonQtShell_QTcpSocket() { | ||||
| PythonQtPrivate* priv = PythonQt::priv(); | ||||
| if (priv) { priv->shellClassDeleted(this); } | ||||
| } | ||||
| bool PythonQtShell_QTcpSocket::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 QTcpSocket::atEnd(); | ||||
| } | ||||
| qint64 PythonQtShell_QTcpSocket::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 QTcpSocket::bytesAvailable(); | ||||
| } | ||||
| qint64 PythonQtShell_QTcpSocket::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 QTcpSocket::bytesToWrite(); | ||||
| } | ||||
| bool PythonQtShell_QTcpSocket::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 QTcpSocket::canReadLine(); | ||||
| } | ||||
| void PythonQtShell_QTcpSocket::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; | ||||
| } | ||||
| } | ||||
| QTcpSocket::childEvent(arg__1); | ||||
| } | ||||
| void PythonQtShell_QTcpSocket::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; | ||||
| } | ||||
| } | ||||
| QTcpSocket::close(); | ||||
| } | ||||
| void PythonQtShell_QTcpSocket::connectToHost(const QHostAddress& address, unsigned short port, QIODevice::OpenMode mode) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "connectToHost"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"" , "const QHostAddress&" , "unsigned short" , "QIODevice::OpenMode"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
| void* args[4] = {NULL, (void*)&address, (void*)&port, (void*)&mode}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return; | ||||
| } | ||||
| } | ||||
| QTcpSocket::connectToHost(address, port, mode); | ||||
| } | ||||
| void PythonQtShell_QTcpSocket::connectToHost(const QString& hostName, unsigned short port, QIODevice::OpenMode mode, QAbstractSocket::NetworkLayerProtocol protocol) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "connectToHost"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"" , "const QString&" , "unsigned short" , "QIODevice::OpenMode" , "QAbstractSocket::NetworkLayerProtocol"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList); | ||||
| void* args[5] = {NULL, (void*)&hostName, (void*)&port, (void*)&mode, (void*)&protocol}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return; | ||||
| } | ||||
| } | ||||
| QTcpSocket::connectToHost(hostName, port, mode, protocol); | ||||
| } | ||||
| void PythonQtShell_QTcpSocket::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; | ||||
| } | ||||
| } | ||||
| QTcpSocket::customEvent(arg__1); | ||||
| } | ||||
| void PythonQtShell_QTcpSocket::disconnectFromHost() | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "disconnectFromHost"); | ||||
| 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; | ||||
| } | ||||
| } | ||||
| QTcpSocket::disconnectFromHost(); | ||||
| } | ||||
| bool PythonQtShell_QTcpSocket::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 QTcpSocket::event(arg__1); | ||||
| } | ||||
| bool PythonQtShell_QTcpSocket::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 QTcpSocket::eventFilter(arg__1, arg__2); | ||||
| } | ||||
| bool PythonQtShell_QTcpSocket::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 QTcpSocket::isSequential(); | ||||
| } | ||||
| bool PythonQtShell_QTcpSocket::open(QIODevice::OpenMode mode) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "open"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"bool" , "QIODevice::OpenMode"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| bool returnValue; | ||||
| void* args[2] = {NULL, (void*)&mode}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { | ||||
| args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
| if (args[0]!=&returnValue) { | ||||
| if (args[0]==NULL) { | ||||
| PythonQt::priv()->handleVirtualOverloadReturnError("open", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((bool*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QTcpSocket::open(mode); | ||||
| } | ||||
| qint64 PythonQtShell_QTcpSocket::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 QTcpSocket::pos(); | ||||
| } | ||||
| qint64 PythonQtShell_QTcpSocket::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 QTcpSocket::readData(data, maxlen); | ||||
| } | ||||
| qint64 PythonQtShell_QTcpSocket::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 QTcpSocket::readLineData(data, maxlen); | ||||
| } | ||||
| bool PythonQtShell_QTcpSocket::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 QTcpSocket::reset(); | ||||
| } | ||||
| void PythonQtShell_QTcpSocket::resume() | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resume"); | ||||
| 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; | ||||
| } | ||||
| } | ||||
| QTcpSocket::resume(); | ||||
| } | ||||
| bool PythonQtShell_QTcpSocket::seek(qint64 pos) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "seek"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"bool" , "qint64"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| bool returnValue; | ||||
| void* args[2] = {NULL, (void*)&pos}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { | ||||
| args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
| if (args[0]!=&returnValue) { | ||||
| if (args[0]==NULL) { | ||||
| PythonQt::priv()->handleVirtualOverloadReturnError("seek", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((bool*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QTcpSocket::seek(pos); | ||||
| } | ||||
| void PythonQtShell_QTcpSocket::setReadBufferSize(qint64 size) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setReadBufferSize"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"" , "qint64"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| void* args[2] = {NULL, (void*)&size}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return; | ||||
| } | ||||
| } | ||||
| QTcpSocket::setReadBufferSize(size); | ||||
| } | ||||
| void PythonQtShell_QTcpSocket::setSocketOption(QAbstractSocket::SocketOption option, const QVariant& value) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setSocketOption"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"" , "QAbstractSocket::SocketOption" , "const QVariant&"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
| void* args[3] = {NULL, (void*)&option, (void*)&value}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return; | ||||
| } | ||||
| } | ||||
| QTcpSocket::setSocketOption(option, value); | ||||
| } | ||||
| qint64 PythonQtShell_QTcpSocket::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 QTcpSocket::size(); | ||||
| } | ||||
| QVariant PythonQtShell_QTcpSocket::socketOption(QAbstractSocket::SocketOption option) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "socketOption"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"QVariant" , "QAbstractSocket::SocketOption"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| QVariant returnValue; | ||||
| void* args[2] = {NULL, (void*)&option}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { | ||||
| args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
| if (args[0]!=&returnValue) { | ||||
| if (args[0]==NULL) { | ||||
| PythonQt::priv()->handleVirtualOverloadReturnError("socketOption", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((QVariant*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QTcpSocket::socketOption(option); | ||||
| } | ||||
| void PythonQtShell_QTcpSocket::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; | ||||
| } | ||||
| } | ||||
| QTcpSocket::timerEvent(arg__1); | ||||
| } | ||||
| bool PythonQtShell_QTcpSocket::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 QTcpSocket::waitForBytesWritten(msecs); | ||||
| } | ||||
| bool PythonQtShell_QTcpSocket::waitForConnected(int msecs) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "waitForConnected"); | ||||
| 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("waitForConnected", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((bool*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QTcpSocket::waitForConnected(msecs); | ||||
| } | ||||
| bool PythonQtShell_QTcpSocket::waitForDisconnected(int msecs) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "waitForDisconnected"); | ||||
| 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("waitForDisconnected", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((bool*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QTcpSocket::waitForDisconnected(msecs); | ||||
| } | ||||
| bool PythonQtShell_QTcpSocket::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 QTcpSocket::waitForReadyRead(msecs); | ||||
| } | ||||
| qint64 PythonQtShell_QTcpSocket::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 QTcpSocket::writeData(data, len); | ||||
| } | ||||
| QTcpSocket* PythonQtWrapper_QTcpSocket::new_QTcpSocket(QObject* parent) | ||||
| { | ||||
| return new PythonQtShell_QTcpSocket(parent); } | ||||
| PythonQtShell_QUdpSocket::~PythonQtShell_QUdpSocket() { | ||||
| PythonQtPrivate* priv = PythonQt::priv(); | ||||
| if (priv) { priv->shellClassDeleted(this); } | ||||
| } | ||||
| bool PythonQtShell_QUdpSocket::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 QUdpSocket::atEnd(); | ||||
| } | ||||
| qint64 PythonQtShell_QUdpSocket::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 QUdpSocket::bytesAvailable(); | ||||
| } | ||||
| qint64 PythonQtShell_QUdpSocket::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 QUdpSocket::bytesToWrite(); | ||||
| } | ||||
| bool PythonQtShell_QUdpSocket::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 QUdpSocket::canReadLine(); | ||||
| } | ||||
| void PythonQtShell_QUdpSocket::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; | ||||
| } | ||||
| } | ||||
| QUdpSocket::childEvent(arg__1); | ||||
| } | ||||
| void PythonQtShell_QUdpSocket::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; | ||||
| } | ||||
| } | ||||
| QUdpSocket::close(); | ||||
| } | ||||
| void PythonQtShell_QUdpSocket::connectToHost(const QHostAddress& address, unsigned short port, QIODevice::OpenMode mode) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "connectToHost"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"" , "const QHostAddress&" , "unsigned short" , "QIODevice::OpenMode"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList); | ||||
| void* args[4] = {NULL, (void*)&address, (void*)&port, (void*)&mode}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return; | ||||
| } | ||||
| } | ||||
| QUdpSocket::connectToHost(address, port, mode); | ||||
| } | ||||
| void PythonQtShell_QUdpSocket::connectToHost(const QString& hostName, unsigned short port, QIODevice::OpenMode mode, QAbstractSocket::NetworkLayerProtocol protocol) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "connectToHost"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"" , "const QString&" , "unsigned short" , "QIODevice::OpenMode" , "QAbstractSocket::NetworkLayerProtocol"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList); | ||||
| void* args[5] = {NULL, (void*)&hostName, (void*)&port, (void*)&mode, (void*)&protocol}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return; | ||||
| } | ||||
| } | ||||
| QUdpSocket::connectToHost(hostName, port, mode, protocol); | ||||
| } | ||||
| void PythonQtShell_QUdpSocket::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; | ||||
| } | ||||
| } | ||||
| QUdpSocket::customEvent(arg__1); | ||||
| } | ||||
| void PythonQtShell_QUdpSocket::disconnectFromHost() | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "disconnectFromHost"); | ||||
| 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; | ||||
| } | ||||
| } | ||||
| QUdpSocket::disconnectFromHost(); | ||||
| } | ||||
| bool PythonQtShell_QUdpSocket::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 QUdpSocket::event(arg__1); | ||||
| } | ||||
| bool PythonQtShell_QUdpSocket::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 QUdpSocket::eventFilter(arg__1, arg__2); | ||||
| } | ||||
| bool PythonQtShell_QUdpSocket::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 QUdpSocket::isSequential(); | ||||
| } | ||||
| bool PythonQtShell_QUdpSocket::open(QIODevice::OpenMode mode) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "open"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"bool" , "QIODevice::OpenMode"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| bool returnValue; | ||||
| void* args[2] = {NULL, (void*)&mode}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { | ||||
| args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
| if (args[0]!=&returnValue) { | ||||
| if (args[0]==NULL) { | ||||
| PythonQt::priv()->handleVirtualOverloadReturnError("open", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((bool*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QUdpSocket::open(mode); | ||||
| } | ||||
| qint64 PythonQtShell_QUdpSocket::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 QUdpSocket::pos(); | ||||
| } | ||||
| qint64 PythonQtShell_QUdpSocket::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 QUdpSocket::readData(data, maxlen); | ||||
| } | ||||
| qint64 PythonQtShell_QUdpSocket::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 QUdpSocket::readLineData(data, maxlen); | ||||
| } | ||||
| bool PythonQtShell_QUdpSocket::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 QUdpSocket::reset(); | ||||
| } | ||||
| void PythonQtShell_QUdpSocket::resume() | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "resume"); | ||||
| 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; | ||||
| } | ||||
| } | ||||
| QUdpSocket::resume(); | ||||
| } | ||||
| bool PythonQtShell_QUdpSocket::seek(qint64 pos) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "seek"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"bool" , "qint64"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| bool returnValue; | ||||
| void* args[2] = {NULL, (void*)&pos}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { | ||||
| args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
| if (args[0]!=&returnValue) { | ||||
| if (args[0]==NULL) { | ||||
| PythonQt::priv()->handleVirtualOverloadReturnError("seek", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((bool*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QUdpSocket::seek(pos); | ||||
| } | ||||
| void PythonQtShell_QUdpSocket::setReadBufferSize(qint64 size) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setReadBufferSize"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"" , "qint64"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| void* args[2] = {NULL, (void*)&size}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return; | ||||
| } | ||||
| } | ||||
| QUdpSocket::setReadBufferSize(size); | ||||
| } | ||||
| void PythonQtShell_QUdpSocket::setSocketOption(QAbstractSocket::SocketOption option, const QVariant& value) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setSocketOption"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"" , "QAbstractSocket::SocketOption" , "const QVariant&"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
| void* args[3] = {NULL, (void*)&option, (void*)&value}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return; | ||||
| } | ||||
| } | ||||
| QUdpSocket::setSocketOption(option, value); | ||||
| } | ||||
| qint64 PythonQtShell_QUdpSocket::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 QUdpSocket::size(); | ||||
| } | ||||
| QVariant PythonQtShell_QUdpSocket::socketOption(QAbstractSocket::SocketOption option) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "socketOption"); | ||||
| PyErr_Clear(); | ||||
| if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
| static const char* argumentList[] ={"QVariant" , "QAbstractSocket::SocketOption"}; | ||||
| static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
| QVariant returnValue; | ||||
| void* args[2] = {NULL, (void*)&option}; | ||||
| PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
| if (result) { | ||||
| args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
| if (args[0]!=&returnValue) { | ||||
| if (args[0]==NULL) { | ||||
| PythonQt::priv()->handleVirtualOverloadReturnError("socketOption", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((QVariant*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QUdpSocket::socketOption(option); | ||||
| } | ||||
| void PythonQtShell_QUdpSocket::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; | ||||
| } | ||||
| } | ||||
| QUdpSocket::timerEvent(arg__1); | ||||
| } | ||||
| bool PythonQtShell_QUdpSocket::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 QUdpSocket::waitForBytesWritten(msecs); | ||||
| } | ||||
| bool PythonQtShell_QUdpSocket::waitForConnected(int msecs) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "waitForConnected"); | ||||
| 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("waitForConnected", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((bool*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QUdpSocket::waitForConnected(msecs); | ||||
| } | ||||
| bool PythonQtShell_QUdpSocket::waitForDisconnected(int msecs) | ||||
| { | ||||
| if (_wrapper) { | ||||
| PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "waitForDisconnected"); | ||||
| 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("waitForDisconnected", methodInfo, result); | ||||
| } else { | ||||
| returnValue = *((bool*)args[0]); | ||||
| } | ||||
| } | ||||
| } | ||||
| if (result) { Py_DECREF(result); } | ||||
| Py_DECREF(obj); | ||||
| return returnValue; | ||||
| } | ||||
| } | ||||
| return QUdpSocket::waitForDisconnected(msecs); | ||||
| } | ||||
| bool PythonQtShell_QUdpSocket::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 QUdpSocket::waitForReadyRead(msecs); | ||||
| } | ||||
| qint64 PythonQtShell_QUdpSocket::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 QUdpSocket::writeData(data, len); | ||||
| } | ||||
| QUdpSocket* PythonQtWrapper_QUdpSocket::new_QUdpSocket(QObject* parent) | ||||
| { | ||||
| return new PythonQtShell_QUdpSocket(parent); } | ||||
| bool PythonQtWrapper_QUdpSocket::hasPendingDatagrams(QUdpSocket* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->hasPendingDatagrams()); | ||||
| } | ||||
| bool PythonQtWrapper_QUdpSocket::joinMulticastGroup(QUdpSocket* theWrappedObject, const QHostAddress& groupAddress) | ||||
| { | ||||
| return ( theWrappedObject->joinMulticastGroup(groupAddress)); | ||||
| } | ||||
| bool PythonQtWrapper_QUdpSocket::joinMulticastGroup(QUdpSocket* theWrappedObject, const QHostAddress& groupAddress, const QNetworkInterface& iface) | ||||
| { | ||||
| return ( theWrappedObject->joinMulticastGroup(groupAddress, iface)); | ||||
| } | ||||
| bool PythonQtWrapper_QUdpSocket::leaveMulticastGroup(QUdpSocket* theWrappedObject, const QHostAddress& groupAddress) | ||||
| { | ||||
| return ( theWrappedObject->leaveMulticastGroup(groupAddress)); | ||||
| } | ||||
| bool PythonQtWrapper_QUdpSocket::leaveMulticastGroup(QUdpSocket* theWrappedObject, const QHostAddress& groupAddress, const QNetworkInterface& iface) | ||||
| { | ||||
| return ( theWrappedObject->leaveMulticastGroup(groupAddress, iface)); | ||||
| } | ||||
| QNetworkInterface PythonQtWrapper_QUdpSocket::multicastInterface(QUdpSocket* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->multicastInterface()); | ||||
| } | ||||
| qint64 PythonQtWrapper_QUdpSocket::pendingDatagramSize(QUdpSocket* theWrappedObject) const | ||||
| { | ||||
| return ( theWrappedObject->pendingDatagramSize()); | ||||
| } | ||||
| qint64 PythonQtWrapper_QUdpSocket::readDatagram(QUdpSocket* theWrappedObject, char* data, qint64 maxlen, QHostAddress* host, unsigned short* port) | ||||
| { | ||||
| return ( theWrappedObject->readDatagram(data, maxlen, host, port)); | ||||
| } | ||||
| void PythonQtWrapper_QUdpSocket::setMulticastInterface(QUdpSocket* theWrappedObject, const QNetworkInterface& iface) | ||||
| { | ||||
| ( theWrappedObject->setMulticastInterface(iface)); | ||||
| } | ||||
| qint64 PythonQtWrapper_QUdpSocket::writeDatagram(QUdpSocket* theWrappedObject, const QByteArray& datagram, const QHostAddress& host, unsigned short port) | ||||
| { | ||||
| return ( theWrappedObject->writeDatagram(datagram, host, port)); | ||||
| } | ||||