com_trolltech_qt_network0.cpp
6580 lines
| 232.3 KiB
| text/x-c
|
CppLexer
florianlink
|
r99 | #include "com_trolltech_qt_network0.h" | ||
#include <PythonQtConversion.h> | ||||
#include <PythonQtMethodInfo.h> | ||||
#include <PythonQtSignalReceiver.h> | ||||
#include <QDateTime> | ||||
#include <QVariant> | ||||
florianlink
|
r110 | #include <qabstractnetworkcache.h> | ||
florianlink
|
r99 | #include <qabstractsocket.h> | ||
#include <qauthenticator.h> | ||||
#include <qbytearray.h> | ||||
#include <qcoreevent.h> | ||||
#include <qdatastream.h> | ||||
#include <qdatetime.h> | ||||
#include <qftp.h> | ||||
#include <qhostaddress.h> | ||||
#include <qhostinfo.h> | ||||
#include <qhttp.h> | ||||
florianlink
|
r186 | #include <qhttpmultipart.h> | ||
florianlink
|
r99 | #include <qiodevice.h> | ||
#include <qlist.h> | ||||
#include <qlocalserver.h> | ||||
#include <qlocalsocket.h> | ||||
#include <qnetworkaccessmanager.h> | ||||
#include <qnetworkcookie.h> | ||||
florianlink
|
r110 | #include <qnetworkcookiejar.h> | ||
#include <qnetworkdiskcache.h> | ||||
florianlink
|
r99 | #include <qnetworkinterface.h> | ||
#include <qnetworkproxy.h> | ||||
#include <qnetworkreply.h> | ||||
#include <qnetworkrequest.h> | ||||
#include <qobject.h> | ||||
#include <qpair.h> | ||||
#include <qstringlist.h> | ||||
florianlink
|
r120 | #include <qtcpserver.h> | ||
florianlink
|
r99 | #include <qtcpsocket.h> | ||
#include <qurl.h> | ||||
#include <qurlinfo.h> | ||||
florianlink
|
r186 | PythonQtShell_QAbstractNetworkCache::~PythonQtShell_QAbstractNetworkCache() { | ||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
florianlink
|
r128 | qint64 PythonQtShell_QAbstractNetworkCache::cacheSize() const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "cacheSize"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"qint64"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
qint64 returnValue; | ||||
void* args[1] = {NULL}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("cacheSize", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((qint64*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return qint64(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtShell_QAbstractNetworkCache::childEvent(QChildEvent* arg__1) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "QChildEvent*"}; | ||
florianlink
|
r110 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r128 | void* args[2] = {NULL, (void*)&arg__1}; | ||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
florianlink
|
r128 | return; | ||
florianlink
|
r99 | } | ||
} | ||||
florianlink
|
r128 | QAbstractNetworkCache::childEvent(arg__1); | ||
florianlink
|
r99 | } | ||
florianlink
|
r110 | void PythonQtShell_QAbstractNetworkCache::clear() | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r110 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "clear"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r110 | static const char* argumentList[] ={""}; | ||
florianlink
|
r99 | 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); | ||||
florianlink
|
r110 | return; | ||
florianlink
|
r99 | } | ||
} | ||||
florianlink
|
r110 | |||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtShell_QAbstractNetworkCache::customEvent(QEvent* arg__1) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "QEvent*"}; | ||
florianlink
|
r99 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r128 | void* args[2] = {NULL, (void*)&arg__1}; | ||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
florianlink
|
r110 | return; | ||
florianlink
|
r99 | } | ||
} | ||||
florianlink
|
r128 | QAbstractNetworkCache::customEvent(arg__1); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QIODevice* PythonQtShell_QAbstractNetworkCache::data(const QUrl& url) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "data"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"QIODevice*" , "const QUrl&"}; | ||
florianlink
|
r110 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r128 | QIODevice* returnValue; | ||
void* args[2] = {NULL, (void*)&url}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
florianlink
|
r128 | if (result) { | ||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("data", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QIODevice**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
florianlink
|
r99 | if (result) { Py_DECREF(result); } | ||
Py_DECREF(obj); | ||||
florianlink
|
r128 | return returnValue; | ||
florianlink
|
r99 | } | ||
} | ||||
florianlink
|
r128 | return 0; | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtShell_QAbstractNetworkCache::event(QEvent* arg__1) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"bool" , "QEvent*"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((bool*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QAbstractNetworkCache::event(arg__1); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | bool PythonQtShell_QAbstractNetworkCache::eventFilter(QObject* arg__1, QEvent* arg__2) | ||
florianlink
|
r120 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter"); | ||
florianlink
|
r120 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
bool returnValue; | ||||
void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2}; | ||||
florianlink
|
r120 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result); | ||
florianlink
|
r120 | } else { | ||
florianlink
|
r128 | returnValue = *((bool*)args[0]); | ||
florianlink
|
r120 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QAbstractNetworkCache::eventFilter(arg__1, arg__2); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtShell_QAbstractNetworkCache::insert(QIODevice* device) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "insert"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "QIODevice*"}; | ||
florianlink
|
r110 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r128 | 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; | ||||
florianlink
|
r110 | void* args[2] = {NULL, (void*)&url}; | ||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("metaData", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((QNetworkCacheMetaData*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QNetworkCacheMetaData(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QIODevice* PythonQtShell_QAbstractNetworkCache::prepare(const QNetworkCacheMetaData& metaData) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "prepare"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"QIODevice*" , "const QNetworkCacheMetaData&"}; | ||
florianlink
|
r110 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r128 | QIODevice* returnValue; | ||
void* args[2] = {NULL, (void*)&metaData}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("prepare", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((QIODevice**)args[0]); | ||
florianlink
|
r120 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return 0; | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | bool PythonQtShell_QAbstractNetworkCache::remove(const QUrl& url) | ||
florianlink
|
r120 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "remove"); | ||
florianlink
|
r120 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"bool" , "const QUrl&"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
florianlink
|
r120 | bool returnValue; | ||
florianlink
|
r128 | void* args[2] = {NULL, (void*)&url}; | ||
florianlink
|
r120 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("remove", methodInfo, result); | ||
florianlink
|
r120 | } else { | ||
returnValue = *((bool*)args[0]); | ||||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return bool(); | ||
florianlink
|
r117 | } | ||
florianlink
|
r128 | void PythonQtShell_QAbstractNetworkCache::timerEvent(QTimerEvent* arg__1) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "QTimerEvent*"}; | ||
florianlink
|
r99 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r110 | void* args[2] = {NULL, (void*)&arg__1}; | ||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
florianlink
|
r110 | return; | ||
florianlink
|
r99 | } | ||
} | ||||
florianlink
|
r128 | QAbstractNetworkCache::timerEvent(arg__1); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtShell_QAbstractNetworkCache::updateMetaData(const QNetworkCacheMetaData& metaData) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateMetaData"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "const QNetworkCacheMetaData&"}; | ||
florianlink
|
r110 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r128 | void* args[2] = {NULL, (void*)&metaData}; | ||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
florianlink
|
r110 | return; | ||
florianlink
|
r99 | } | ||
} | ||||
florianlink
|
r128 | |||
florianlink
|
r99 | } | ||
florianlink
|
r120 | |||
florianlink
|
r186 | PythonQtShell_QAbstractSocket::~PythonQtShell_QAbstractSocket() { | ||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
florianlink
|
r128 | bool PythonQtShell_QAbstractSocket::atEnd() const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "atEnd"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"bool"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
florianlink
|
r110 | bool returnValue; | ||
florianlink
|
r128 | void* args[1] = {NULL}; | ||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("atEnd", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r110 | returnValue = *((bool*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QAbstractSocket::atEnd(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | qint64 PythonQtShell_QAbstractSocket::bytesAvailable() const | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "bytesAvailable"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"qint64"}; | ||
florianlink
|
r120 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||
florianlink
|
r128 | qint64 returnValue; | ||
florianlink
|
r120 | void* args[1] = {NULL}; | ||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("bytesAvailable", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((qint64*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QAbstractSocket::bytesAvailable(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | qint64 PythonQtShell_QAbstractSocket::bytesToWrite() const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "bytesToWrite"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r120 | static const char* argumentList[] ={"qint64"}; | ||
florianlink
|
r99 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||
florianlink
|
r120 | qint64 returnValue; | ||
florianlink
|
r99 | 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) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("bytesToWrite", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r120 | returnValue = *((qint64*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QAbstractSocket::bytesToWrite(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r120 | bool PythonQtShell_QAbstractSocket::canReadLine() const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r120 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "canReadLine"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r120 | static const char* argumentList[] ={"bool"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
bool returnValue; | ||||
void* args[1] = {NULL}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r120 | PythonQt::priv()->handleVirtualOverloadReturnError("canReadLine", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r120 | returnValue = *((bool*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r120 | return QAbstractSocket::canReadLine(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtShell_QAbstractSocket::childEvent(QChildEvent* arg__1) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "QChildEvent*"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
florianlink
|
r128 | 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::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); | ||||
} | ||||
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) { | ||||
florianlink
|
r99 | if (args[0]==NULL) { | ||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((bool*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QAbstractSocket::event(arg__1); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtShell_QAbstractSocket::eventFilter(QObject* arg__1, QEvent* arg__2) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
florianlink
|
r110 | bool returnValue; | ||
florianlink
|
r128 | void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2}; | ||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r110 | returnValue = *((bool*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QAbstractSocket::eventFilter(arg__1, arg__2); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtShell_QAbstractSocket::isSequential() const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isSequential"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"bool"}; | ||
florianlink
|
r110 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||
florianlink
|
r128 | bool returnValue; | ||
florianlink
|
r110 | void* args[1] = {NULL}; | ||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
florianlink
|
r128 | if (result) { | ||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("isSequential", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
florianlink
|
r99 | if (result) { Py_DECREF(result); } | ||
Py_DECREF(obj); | ||||
florianlink
|
r128 | return returnValue; | ||
florianlink
|
r99 | } | ||
} | ||||
florianlink
|
r128 | return QAbstractSocket::isSequential(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtShell_QAbstractSocket::open(QIODevice::OpenMode mode) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "open"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"bool" , "QIODevice::OpenMode"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
florianlink
|
r99 | bool returnValue; | ||
florianlink
|
r128 | void* args[2] = {NULL, (void*)&mode}; | ||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("open", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QAbstractSocket::open(mode); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | qint64 PythonQtShell_QAbstractSocket::pos() const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "pos"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"qint64"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
florianlink
|
r120 | qint64 returnValue; | ||
florianlink
|
r128 | void* args[1] = {NULL}; | ||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
florianlink
|
r110 | if (result) { | ||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("pos", methodInfo, result); | ||
florianlink
|
r110 | } else { | ||
florianlink
|
r120 | returnValue = *((qint64*)args[0]); | ||
florianlink
|
r110 | } | ||
} | ||||
} | ||||
florianlink
|
r99 | if (result) { Py_DECREF(result); } | ||
Py_DECREF(obj); | ||||
florianlink
|
r110 | return returnValue; | ||
florianlink
|
r99 | } | ||
} | ||||
florianlink
|
r128 | return QAbstractSocket::pos(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r120 | qint64 PythonQtShell_QAbstractSocket::readData(char* data, qint64 maxlen) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r120 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "readData"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r120 | 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}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
florianlink
|
r110 | if (result) { | ||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r120 | PythonQt::priv()->handleVirtualOverloadReturnError("readData", methodInfo, result); | ||
florianlink
|
r110 | } else { | ||
florianlink
|
r120 | returnValue = *((qint64*)args[0]); | ||
florianlink
|
r110 | } | ||
} | ||||
} | ||||
florianlink
|
r99 | if (result) { Py_DECREF(result); } | ||
Py_DECREF(obj); | ||||
florianlink
|
r110 | return returnValue; | ||
florianlink
|
r99 | } | ||
} | ||||
florianlink
|
r120 | return QAbstractSocket::readData(data, maxlen); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | qint64 PythonQtShell_QAbstractSocket::readLineData(char* data, qint64 maxlen) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "readLineData"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"qint64" , "char*" , "qint64"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
florianlink
|
r110 | qint64 returnValue; | ||
florianlink
|
r128 | void* args[3] = {NULL, (void*)&data, (void*)&maxlen}; | ||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("readLineData", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r110 | returnValue = *((qint64*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QAbstractSocket::readLineData(data, maxlen); | ||
florianlink
|
r99 | } | ||
florianlink
|
r120 | bool PythonQtShell_QAbstractSocket::reset() | ||
florianlink
|
r99 | { | ||
florianlink
|
r110 | if (_wrapper) { | ||
florianlink
|
r120 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reset"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r120 | static const char* argumentList[] ={"bool"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
bool returnValue; | ||||
void* args[1] = {NULL}; | ||||
florianlink
|
r110 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r120 | PythonQt::priv()->handleVirtualOverloadReturnError("reset", methodInfo, result); | ||
florianlink
|
r110 | } else { | ||
florianlink
|
r120 | returnValue = *((bool*)args[0]); | ||
florianlink
|
r110 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
florianlink
|
r99 | } | ||
florianlink
|
r120 | return QAbstractSocket::reset(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtShell_QAbstractSocket::seek(qint64 pos) | ||
florianlink
|
r99 | { | ||
florianlink
|
r110 | if (_wrapper) { | ||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "seek"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"bool" , "qint64"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&pos}; | ||||
florianlink
|
r110 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("seek", methodInfo, result); | ||
florianlink
|
r110 | } else { | ||
florianlink
|
r128 | returnValue = *((bool*)args[0]); | ||
florianlink
|
r110 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
florianlink
|
r99 | } | ||
florianlink
|
r128 | return QAbstractSocket::seek(pos); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | qint64 PythonQtShell_QAbstractSocket::size() const | ||
florianlink
|
r99 | { | ||
florianlink
|
r110 | if (_wrapper) { | ||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "size"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"qint64"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
qint64 returnValue; | ||||
void* args[1] = {NULL}; | ||||
florianlink
|
r110 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("size", methodInfo, result); | ||
florianlink
|
r110 | } else { | ||
florianlink
|
r128 | returnValue = *((qint64*)args[0]); | ||
florianlink
|
r110 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
florianlink
|
r99 | } | ||
florianlink
|
r128 | return QAbstractSocket::size(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtShell_QAbstractSocket::timerEvent(QTimerEvent* arg__1) | ||
florianlink
|
r99 | { | ||
florianlink
|
r110 | if (_wrapper) { | ||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "QTimerEvent*"}; | ||
florianlink
|
r120 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r128 | void* args[2] = {NULL, (void*)&arg__1}; | ||
florianlink
|
r110 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
florianlink
|
r128 | return; | ||
florianlink
|
r110 | } | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QAbstractSocket::timerEvent(arg__1); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtShell_QAbstractSocket::waitForBytesWritten(int msecs) | ||
florianlink
|
r99 | { | ||
florianlink
|
r110 | if (_wrapper) { | ||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "waitForBytesWritten"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"bool" , "int"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&msecs}; | ||||
florianlink
|
r110 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("waitForBytesWritten", methodInfo, result); | ||
florianlink
|
r110 | } else { | ||
florianlink
|
r128 | returnValue = *((bool*)args[0]); | ||
florianlink
|
r110 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
florianlink
|
r99 | } | ||
florianlink
|
r128 | return QAbstractSocket::waitForBytesWritten(msecs); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtShell_QAbstractSocket::waitForReadyRead(int msecs) | ||
florianlink
|
r99 | { | ||
florianlink
|
r110 | if (_wrapper) { | ||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "waitForReadyRead"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"bool" , "int"}; | ||
florianlink
|
r117 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
bool returnValue; | ||||
florianlink
|
r128 | void* args[2] = {NULL, (void*)&msecs}; | ||
florianlink
|
r110 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("waitForReadyRead", methodInfo, result); | ||
florianlink
|
r110 | } else { | ||
florianlink
|
r117 | returnValue = *((bool*)args[0]); | ||
florianlink
|
r110 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QAbstractSocket::waitForReadyRead(msecs); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | qint64 PythonQtShell_QAbstractSocket::writeData(const char* data, qint64 len) | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "writeData"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"qint64" , "const char*" , "qint64"}; | ||
florianlink
|
r120 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||
florianlink
|
r128 | qint64 returnValue; | ||
void* args[3] = {NULL, (void*)&data, (void*)&len}; | ||||
florianlink
|
r110 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("writeData", methodInfo, result); | ||
florianlink
|
r110 | } else { | ||
florianlink
|
r128 | returnValue = *((qint64*)args[0]); | ||
florianlink
|
r110 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QAbstractSocket::writeData(data, len); | ||
florianlink
|
r117 | } | ||
florianlink
|
r128 | QAbstractSocket* PythonQtWrapper_QAbstractSocket::new_QAbstractSocket(QAbstractSocket::SocketType socketType, QObject* parent) | ||
{ | ||||
return new PythonQtShell_QAbstractSocket(socketType, parent); } | ||||
void PythonQtWrapper_QAbstractSocket::abort(QAbstractSocket* theWrappedObject) | ||||
florianlink
|
r117 | { | ||
florianlink
|
r128 | ( theWrappedObject->abort()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QAbstractSocket::atEnd(QAbstractSocket* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_atEnd()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | qint64 PythonQtWrapper_QAbstractSocket::bytesAvailable(QAbstractSocket* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_bytesAvailable()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | qint64 PythonQtWrapper_QAbstractSocket::bytesToWrite(QAbstractSocket* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_bytesToWrite()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QAbstractSocket::canReadLine(QAbstractSocket* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_canReadLine()); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QAbstractSocket::close(QAbstractSocket* theWrappedObject) | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | ( ((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_close()); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QAbstractSocket::connectToHost(QAbstractSocket* theWrappedObject, const QHostAddress& address, unsigned short port, QIODevice::OpenMode mode) | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | ( theWrappedObject->connectToHost(address, port, mode)); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QAbstractSocket::connectToHost(QAbstractSocket* theWrappedObject, const QString& hostName, unsigned short port, QIODevice::OpenMode mode) | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | ( theWrappedObject->connectToHost(hostName, port, mode)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QAbstractSocket::disconnectFromHost(QAbstractSocket* theWrappedObject) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | ( theWrappedObject->disconnectFromHost()); | ||
florianlink
|
r110 | } | ||
QAbstractSocket::SocketError PythonQtWrapper_QAbstractSocket::error(QAbstractSocket* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->error()); | ||||
} | ||||
florianlink
|
r128 | bool PythonQtWrapper_QAbstractSocket::flush(QAbstractSocket* theWrappedObject) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->flush()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QAbstractSocket::isSequential(QAbstractSocket* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_isSequential()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QAbstractSocket::isValid(QAbstractSocket* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->isValid()); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | QHostAddress PythonQtWrapper_QAbstractSocket::localAddress(QAbstractSocket* theWrappedObject) const | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | return ( theWrappedObject->localAddress()); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | unsigned short PythonQtWrapper_QAbstractSocket::localPort(QAbstractSocket* theWrappedObject) const | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | return ( theWrappedObject->localPort()); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | QHostAddress PythonQtWrapper_QAbstractSocket::peerAddress(QAbstractSocket* theWrappedObject) const | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | return ( theWrappedObject->peerAddress()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QString PythonQtWrapper_QAbstractSocket::peerName(QAbstractSocket* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->peerName()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | unsigned short PythonQtWrapper_QAbstractSocket::peerPort(QAbstractSocket* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->peerPort()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QNetworkProxy PythonQtWrapper_QAbstractSocket::proxy(QAbstractSocket* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->proxy()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | qint64 PythonQtWrapper_QAbstractSocket::readBufferSize(QAbstractSocket* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->readBufferSize()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | qint64 PythonQtWrapper_QAbstractSocket::readData(QAbstractSocket* theWrappedObject, char* data, qint64 maxlen) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_readData(data, maxlen)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | qint64 PythonQtWrapper_QAbstractSocket::readLineData(QAbstractSocket* theWrappedObject, char* data, qint64 maxlen) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_readLineData(data, maxlen)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QAbstractSocket::setProxy(QAbstractSocket* theWrappedObject, const QNetworkProxy& networkProxy) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( theWrappedObject->setProxy(networkProxy)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QAbstractSocket::setReadBufferSize(QAbstractSocket* theWrappedObject, qint64 size) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( theWrappedObject->setReadBufferSize(size)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QAbstractSocket::setSocketDescriptor(QAbstractSocket* theWrappedObject, int socketDescriptor, QAbstractSocket::SocketState state, QIODevice::OpenMode openMode) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->setSocketDescriptor(socketDescriptor, state, openMode)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | int PythonQtWrapper_QAbstractSocket::socketDescriptor(QAbstractSocket* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->socketDescriptor()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | QAbstractSocket::SocketType PythonQtWrapper_QAbstractSocket::socketType(QAbstractSocket* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->socketType()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QAbstractSocket::SocketState PythonQtWrapper_QAbstractSocket::state(QAbstractSocket* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->state()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QAbstractSocket::waitForBytesWritten(QAbstractSocket* theWrappedObject, int msecs) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_waitForBytesWritten(msecs)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QAbstractSocket::waitForConnected(QAbstractSocket* theWrappedObject, int msecs) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->waitForConnected(msecs)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QAbstractSocket::waitForDisconnected(QAbstractSocket* theWrappedObject, int msecs) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->waitForDisconnected(msecs)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QAbstractSocket::waitForReadyRead(QAbstractSocket* theWrappedObject, int msecs) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_waitForReadyRead(msecs)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | qint64 PythonQtWrapper_QAbstractSocket::writeData(QAbstractSocket* theWrappedObject, const char* data, qint64 len) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QAbstractSocket*)theWrappedObject)->promoted_writeData(data, len)); | ||
florianlink
|
r99 | } | ||
QAuthenticator* PythonQtWrapper_QAuthenticator::new_QAuthenticator() | ||||
{ | ||||
return new QAuthenticator(); } | ||||
QAuthenticator* PythonQtWrapper_QAuthenticator::new_QAuthenticator(const QAuthenticator& other) | ||||
{ | ||||
return new QAuthenticator(other); } | ||||
florianlink
|
r128 | bool PythonQtWrapper_QAuthenticator::isNull(QAuthenticator* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->isNull()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QAuthenticator::__ne__(QAuthenticator* theWrappedObject, const QAuthenticator& other) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( (*theWrappedObject)!= other); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QAuthenticator::__eq__(QAuthenticator* theWrappedObject, const QAuthenticator& other) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( (*theWrappedObject)== other); | ||
florianlink
|
r99 | } | ||
florianlink
|
r186 | 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()); | ||||
} | ||||
florianlink
|
r128 | QString PythonQtWrapper_QAuthenticator::password(QAuthenticator* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->password()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r120 | QString PythonQtWrapper_QAuthenticator::realm(QAuthenticator* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r120 | return ( theWrappedObject->realm()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r186 | void PythonQtWrapper_QAuthenticator::setOption(QAuthenticator* theWrappedObject, const QString& opt, const QVariant& value) | ||
{ | ||||
( theWrappedObject->setOption(opt, value)); | ||||
} | ||||
florianlink
|
r128 | void PythonQtWrapper_QAuthenticator::setPassword(QAuthenticator* theWrappedObject, const QString& password) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( theWrappedObject->setPassword(password)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QAuthenticator::setUser(QAuthenticator* theWrappedObject, const QString& user) | ||
florianlink
|
r117 | { | ||
florianlink
|
r128 | ( theWrappedObject->setUser(user)); | ||
florianlink
|
r117 | } | ||
florianlink
|
r128 | QString PythonQtWrapper_QAuthenticator::user(QAuthenticator* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->user()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r120 | |||
florianlink
|
r186 | PythonQtShell_QFtp::~PythonQtShell_QFtp() { | ||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
florianlink
|
r128 | void PythonQtShell_QFtp::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; | ||||
} | ||||
} | ||||
QFtp::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QFtp::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; | ||||
} | ||||
} | ||||
QFtp::customEvent(arg__1); | ||||
} | ||||
florianlink
|
r99 | bool PythonQtShell_QFtp::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 QFtp::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QFtp::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 QFtp::eventFilter(arg__1, arg__2); | ||||
} | ||||
florianlink
|
r120 | void PythonQtShell_QFtp::timerEvent(QTimerEvent* arg__1) | ||
florianlink
|
r99 | { | ||
florianlink
|
r120 | 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; | ||||
} | ||||
} | ||||
QFtp::timerEvent(arg__1); | ||||
florianlink
|
r99 | } | ||
florianlink
|
r120 | QFtp* PythonQtWrapper_QFtp::new_QFtp(QObject* parent) | ||
{ | ||||
return new PythonQtShell_QFtp(parent); } | ||||
florianlink
|
r99 | |||
florianlink
|
r128 | qint64 PythonQtWrapper_QFtp::bytesAvailable(QFtp* theWrappedObject) const | ||
{ | ||||
return ( theWrappedObject->bytesAvailable()); | ||||
} | ||||
florianlink
|
r99 | int PythonQtWrapper_QFtp::cd(QFtp* theWrappedObject, const QString& dir) | ||
{ | ||||
return ( theWrappedObject->cd(dir)); | ||||
} | ||||
florianlink
|
r128 | void PythonQtWrapper_QFtp::clearPendingCommands(QFtp* theWrappedObject) | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | ( theWrappedObject->clearPendingCommands()); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | int PythonQtWrapper_QFtp::close(QFtp* theWrappedObject) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->close()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | int PythonQtWrapper_QFtp::connectToHost(QFtp* theWrappedObject, const QString& host, unsigned short port) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->connectToHost(host, port)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r120 | QFtp::Command PythonQtWrapper_QFtp::currentCommand(QFtp* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r120 | return ( theWrappedObject->currentCommand()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QIODevice* PythonQtWrapper_QFtp::currentDevice(QFtp* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->currentDevice()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | int PythonQtWrapper_QFtp::currentId(QFtp* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->currentId()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QFtp::Error PythonQtWrapper_QFtp::error(QFtp* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->error()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QString PythonQtWrapper_QFtp::errorString(QFtp* theWrappedObject) const | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | return ( theWrappedObject->errorString()); | ||
florianlink
|
r120 | } | ||
florianlink
|
r110 | int PythonQtWrapper_QFtp::get(QFtp* theWrappedObject, const QString& file, QIODevice* dev, QFtp::TransferType type) | ||
florianlink
|
r99 | { | ||
florianlink
|
r110 | return ( theWrappedObject->get(file, dev, type)); | ||
florianlink
|
r99 | } | ||
bool PythonQtWrapper_QFtp::hasPendingCommands(QFtp* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->hasPendingCommands()); | ||||
} | ||||
florianlink
|
r128 | int PythonQtWrapper_QFtp::list(QFtp* theWrappedObject, const QString& dir) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->list(dir)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | int PythonQtWrapper_QFtp::login(QFtp* theWrappedObject, const QString& user, const QString& password) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->login(user, password)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | int PythonQtWrapper_QFtp::mkdir(QFtp* theWrappedObject, const QString& dir) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->mkdir(dir)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | int PythonQtWrapper_QFtp::put(QFtp* theWrappedObject, QIODevice* dev, const QString& file, QFtp::TransferType type) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->put(dev, file, type)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r120 | int PythonQtWrapper_QFtp::put(QFtp* theWrappedObject, const QByteArray& data, const QString& file, QFtp::TransferType type) | ||
{ | ||||
return ( theWrappedObject->put(data, file, type)); | ||||
} | ||||
florianlink
|
r128 | int PythonQtWrapper_QFtp::rawCommand(QFtp* theWrappedObject, const QString& command) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->rawCommand(command)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | qint64 PythonQtWrapper_QFtp::read(QFtp* theWrappedObject, char* data, qint64 maxlen) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->read(data, maxlen)); | ||
florianlink
|
r99 | } | ||
QByteArray PythonQtWrapper_QFtp::readAll(QFtp* theWrappedObject) | ||||
{ | ||||
return ( theWrappedObject->readAll()); | ||||
} | ||||
florianlink
|
r120 | int PythonQtWrapper_QFtp::remove(QFtp* theWrappedObject, const QString& file) | ||
florianlink
|
r99 | { | ||
florianlink
|
r120 | return ( theWrappedObject->remove(file)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | int PythonQtWrapper_QFtp::rename(QFtp* theWrappedObject, const QString& oldname, const QString& newname) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->rename(oldname, newname)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | int PythonQtWrapper_QFtp::rmdir(QFtp* theWrappedObject, const QString& dir) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->rmdir(dir)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r120 | int PythonQtWrapper_QFtp::setProxy(QFtp* theWrappedObject, const QString& host, unsigned short port) | ||
florianlink
|
r99 | { | ||
florianlink
|
r120 | return ( theWrappedObject->setProxy(host, port)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | int PythonQtWrapper_QFtp::setTransferMode(QFtp* theWrappedObject, QFtp::TransferMode mode) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->setTransferMode(mode)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QFtp::State PythonQtWrapper_QFtp::state(QFtp* theWrappedObject) const | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | return ( theWrappedObject->state()); | ||
florianlink
|
r120 | } | ||
florianlink
|
r99 | |||
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); } | ||||
florianlink
|
r128 | void PythonQtWrapper_QHostAddress::clear(QHostAddress* theWrappedObject) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( theWrappedObject->clear()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QHostAddress::isInSubnet(QHostAddress* theWrappedObject, const QHostAddress& subnet, int netmask) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->isInSubnet(subnet, netmask)); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QHostAddress::isInSubnet(QHostAddress* theWrappedObject, const QPair<QHostAddress , int >& subnet) const | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | return ( theWrappedObject->isInSubnet(subnet)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QHostAddress::isNull(QHostAddress* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->isNull()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QHostAddress::__ne__(QHostAddress* theWrappedObject, QHostAddress::SpecialAddress address) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( (*theWrappedObject)!= address); | ||
florianlink
|
r99 | } | ||
florianlink
|
r120 | bool PythonQtWrapper_QHostAddress::__ne__(QHostAddress* theWrappedObject, const QHostAddress& address) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r120 | return ( (*theWrappedObject)!= address); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QHostAddress::writeTo(QHostAddress* theWrappedObject, QDataStream& arg__1) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | arg__1 << (*theWrappedObject); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QHostAddress::__eq__(QHostAddress* theWrappedObject, QHostAddress::SpecialAddress address) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( (*theWrappedObject)== address); | ||
florianlink
|
r99 | } | ||
florianlink
|
r120 | bool PythonQtWrapper_QHostAddress::__eq__(QHostAddress* theWrappedObject, const QHostAddress& address) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r120 | return ( (*theWrappedObject)== address); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QHostAddress::readFrom(QHostAddress* theWrappedObject, QDataStream& arg__1) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | arg__1 >> (*theWrappedObject); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QPair<QHostAddress , int > PythonQtWrapper_QHostAddress::static_QHostAddress_parseSubnet(const QString& subnet) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return (QHostAddress::parseSubnet(subnet)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QAbstractSocket::NetworkLayerProtocol PythonQtWrapper_QHostAddress::protocol(QHostAddress* theWrappedObject) const | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | return ( theWrappedObject->protocol()); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | QString PythonQtWrapper_QHostAddress::scopeId(QHostAddress* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->scopeId()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QHostAddress::setAddress(QHostAddress* theWrappedObject, const QIPv6Address& ip6Addr) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | ( theWrappedObject->setAddress(ip6Addr)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QHostAddress::setAddress(QHostAddress* theWrappedObject, const QString& address) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->setAddress(address)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QHostAddress::setAddress(QHostAddress* theWrappedObject, unsigned int ip4Addr) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | ( theWrappedObject->setAddress(ip4Addr)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QHostAddress::setScopeId(QHostAddress* theWrappedObject, const QString& id) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( theWrappedObject->setScopeId(id)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | unsigned int PythonQtWrapper_QHostAddress::toIPv4Address(QHostAddress* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->toIPv4Address()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | QIPv6Address PythonQtWrapper_QHostAddress::toIPv6Address(QHostAddress* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->toIPv6Address()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QString PythonQtWrapper_QHostAddress::toString(QHostAddress* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->toString()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r117 | QString PythonQtWrapper_QHostAddress::py_toString(QHostAddress* obj) { return obj->toString(); } | ||
florianlink
|
r99 | |||
QHostInfo* PythonQtWrapper_QHostInfo::new_QHostInfo(const QHostInfo& d) | ||||
{ | ||||
return new QHostInfo(d); } | ||||
QHostInfo* PythonQtWrapper_QHostInfo::new_QHostInfo(int lookupId) | ||||
{ | ||||
return new QHostInfo(lookupId); } | ||||
florianlink
|
r128 | void PythonQtWrapper_QHostInfo::static_QHostInfo_abortHostLookup(int lookupId) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | (QHostInfo::abortHostLookup(lookupId)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QList<QHostAddress > PythonQtWrapper_QHostInfo::addresses(QHostInfo* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->addresses()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QHostInfo::HostInfoError PythonQtWrapper_QHostInfo::error(QHostInfo* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->error()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QString PythonQtWrapper_QHostInfo::errorString(QHostInfo* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->errorString()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QHostInfo PythonQtWrapper_QHostInfo::static_QHostInfo_fromName(const QString& name) | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | return (QHostInfo::fromName(name)); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | QString PythonQtWrapper_QHostInfo::hostName(QHostInfo* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->hostName()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QString PythonQtWrapper_QHostInfo::static_QHostInfo_localDomainName() | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return (QHostInfo::localDomainName()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QString PythonQtWrapper_QHostInfo::static_QHostInfo_localHostName() | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return (QHostInfo::localHostName()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | int PythonQtWrapper_QHostInfo::static_QHostInfo_lookupHost(const QString& name, QObject* receiver, const char* member) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return (QHostInfo::lookupHost(name, receiver, member)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | int PythonQtWrapper_QHostInfo::lookupId(QHostInfo* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->lookupId()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QHostInfo::setAddresses(QHostInfo* theWrappedObject, const QList<QHostAddress >& addresses) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( theWrappedObject->setAddresses(addresses)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r120 | void PythonQtWrapper_QHostInfo::setError(QHostInfo* theWrappedObject, QHostInfo::HostInfoError error) | ||
{ | ||||
( theWrappedObject->setError(error)); | ||||
} | ||||
florianlink
|
r128 | void PythonQtWrapper_QHostInfo::setErrorString(QHostInfo* theWrappedObject, const QString& errorString) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( theWrappedObject->setErrorString(errorString)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QHostInfo::setHostName(QHostInfo* theWrappedObject, const QString& name) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( theWrappedObject->setHostName(name)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QHostInfo::setLookupId(QHostInfo* theWrappedObject, int id) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | ( theWrappedObject->setLookupId(id)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r99 | |||
florianlink
|
r186 | PythonQtShell_QHttp::~PythonQtShell_QHttp() { | ||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
florianlink
|
r128 | void PythonQtShell_QHttp::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; | ||||
} | ||||
} | ||||
QHttp::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QHttp::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; | ||||
} | ||||
} | ||||
QHttp::customEvent(arg__1); | ||||
} | ||||
florianlink
|
r120 | bool PythonQtShell_QHttp::event(QEvent* arg__1) | ||
florianlink
|
r117 | { | ||
if (_wrapper) { | ||||
florianlink
|
r120 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event"); | ||
florianlink
|
r117 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r120 | static const char* argumentList[] ={"bool" , "QEvent*"}; | ||
florianlink
|
r117 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r120 | bool returnValue; | ||
florianlink
|
r117 | void* args[2] = {NULL, (void*)&arg__1}; | ||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
florianlink
|
r120 | if (result) { | ||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
florianlink
|
r117 | if (result) { Py_DECREF(result); } | ||
Py_DECREF(obj); | ||||
florianlink
|
r120 | return returnValue; | ||
florianlink
|
r117 | } | ||
} | ||||
florianlink
|
r120 | return QHttp::event(arg__1); | ||
florianlink
|
r117 | } | ||
florianlink
|
r120 | bool PythonQtShell_QHttp::eventFilter(QObject* arg__1, QEvent* arg__2) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r120 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r120 | static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
bool returnValue; | ||||
void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
florianlink
|
r120 | if (result) { | ||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
florianlink
|
r99 | if (result) { Py_DECREF(result); } | ||
Py_DECREF(obj); | ||||
florianlink
|
r120 | return returnValue; | ||
florianlink
|
r99 | } | ||
} | ||||
florianlink
|
r120 | return QHttp::eventFilter(arg__1, arg__2); | ||
florianlink
|
r99 | } | ||
florianlink
|
r120 | void PythonQtShell_QHttp::timerEvent(QTimerEvent* arg__1) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r120 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r120 | static const char* argumentList[] ={"" , "QTimerEvent*"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
florianlink
|
r120 | return; | ||
florianlink
|
r99 | } | ||
} | ||||
florianlink
|
r120 | QHttp::timerEvent(arg__1); | ||
florianlink
|
r99 | } | ||
QHttp* PythonQtWrapper_QHttp::new_QHttp(QObject* parent) | ||||
{ | ||||
return new PythonQtShell_QHttp(parent); } | ||||
QHttp* PythonQtWrapper_QHttp::new_QHttp(const QString& hostname, QHttp::ConnectionMode mode, unsigned short port, QObject* parent) | ||||
{ | ||||
return new PythonQtShell_QHttp(hostname, mode, port, parent); } | ||||
QHttp* PythonQtWrapper_QHttp::new_QHttp(const QString& hostname, unsigned short port, QObject* parent) | ||||
{ | ||||
return new PythonQtShell_QHttp(hostname, port, parent); } | ||||
florianlink
|
r120 | qint64 PythonQtWrapper_QHttp::bytesAvailable(QHttp* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r120 | return ( theWrappedObject->bytesAvailable()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QHttp::clearPendingRequests(QHttp* theWrappedObject) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( theWrappedObject->clearPendingRequests()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | int PythonQtWrapper_QHttp::close(QHttp* theWrappedObject) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->close()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QIODevice* PythonQtWrapper_QHttp::currentDestinationDevice(QHttp* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->currentDestinationDevice()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | int PythonQtWrapper_QHttp::currentId(QHttp* theWrappedObject) const | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | return ( theWrappedObject->currentId()); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | QHttpRequestHeader PythonQtWrapper_QHttp::currentRequest(QHttp* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->currentRequest()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QIODevice* PythonQtWrapper_QHttp::currentSourceDevice(QHttp* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->currentSourceDevice()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QHttp::Error PythonQtWrapper_QHttp::error(QHttp* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->error()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r110 | QString PythonQtWrapper_QHttp::errorString(QHttp* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r110 | return ( theWrappedObject->errorString()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | int PythonQtWrapper_QHttp::get(QHttp* theWrappedObject, const QString& path, QIODevice* to) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->get(path, to)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QHttp::hasPendingRequests(QHttp* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->hasPendingRequests()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | int PythonQtWrapper_QHttp::head(QHttp* theWrappedObject, const QString& path) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->head(path)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r120 | QHttpResponseHeader PythonQtWrapper_QHttp::lastResponse(QHttp* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r120 | return ( theWrappedObject->lastResponse()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | int PythonQtWrapper_QHttp::post(QHttp* theWrappedObject, const QString& path, QIODevice* data, QIODevice* to) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->post(path, data, to)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | int PythonQtWrapper_QHttp::post(QHttp* theWrappedObject, const QString& path, const QByteArray& data, QIODevice* to) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->post(path, data, to)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | qint64 PythonQtWrapper_QHttp::read(QHttp* theWrappedObject, char* data, qint64 maxlen) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->read(data, maxlen)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QByteArray PythonQtWrapper_QHttp::readAll(QHttp* theWrappedObject) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->readAll()); | ||
} | ||||
int PythonQtWrapper_QHttp::request(QHttp* theWrappedObject, const QHttpRequestHeader& header, QIODevice* device, QIODevice* to) | ||||
{ | ||||
return ( theWrappedObject->request(header, device, to)); | ||||
florianlink
|
r99 | } | ||
florianlink
|
r110 | int PythonQtWrapper_QHttp::request(QHttp* theWrappedObject, const QHttpRequestHeader& header, const QByteArray& data, QIODevice* to) | ||
florianlink
|
r99 | { | ||
florianlink
|
r110 | return ( theWrappedObject->request(header, data, to)); | ||
} | ||||
florianlink
|
r128 | int PythonQtWrapper_QHttp::setHost(QHttp* theWrappedObject, const QString& hostname, QHttp::ConnectionMode mode, unsigned short port) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->setHost(hostname, mode, port)); | ||
} | ||||
int PythonQtWrapper_QHttp::setHost(QHttp* theWrappedObject, const QString& hostname, unsigned short port) | ||||
{ | ||||
return ( theWrappedObject->setHost(hostname, port)); | ||||
florianlink
|
r110 | } | ||
int PythonQtWrapper_QHttp::setProxy(QHttp* theWrappedObject, const QNetworkProxy& proxy) | ||||
{ | ||||
return ( theWrappedObject->setProxy(proxy)); | ||||
florianlink
|
r99 | } | ||
int PythonQtWrapper_QHttp::setProxy(QHttp* theWrappedObject, const QString& host, int port, const QString& username, const QString& password) | ||||
{ | ||||
return ( theWrappedObject->setProxy(host, port, username, password)); | ||||
} | ||||
florianlink
|
r128 | int PythonQtWrapper_QHttp::setSocket(QHttp* theWrappedObject, QTcpSocket* socket) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->setSocket(socket)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | int PythonQtWrapper_QHttp::setUser(QHttp* theWrappedObject, const QString& username, const QString& password) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->setUser(username, password)); | ||
} | ||||
QHttp::State PythonQtWrapper_QHttp::state(QHttp* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->state()); | ||||
florianlink
|
r110 | } | ||
florianlink
|
r99 | |||
florianlink
|
r186 | PythonQtShell_QHttpHeader::~PythonQtShell_QHttpHeader() { | ||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
florianlink
|
r99 | int PythonQtShell_QHttpHeader::majorVersion() const | ||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "majorVersion"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
int returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("majorVersion", methodInfo, result); | ||||
} else { | ||||
returnValue = *((int*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r120 | return int(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | int PythonQtShell_QHttpHeader::minorVersion() const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "minorVersion"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"int"}; | ||
florianlink
|
r99 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||
florianlink
|
r128 | int returnValue; | ||
florianlink
|
r99 | 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) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("minorVersion", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((int*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return int(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtShell_QHttpHeader::parseLine(const QString& line, int number) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "parseLine"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"bool" , "const QString&" , "int"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
bool returnValue; | ||||
void* args[3] = {NULL, (void*)&line, (void*)&number}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("parseLine", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((bool*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QHttpHeader::parseLine(line, number); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QString PythonQtShell_QHttpHeader::toString() const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toString"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"QString"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QString returnValue; | ||||
void* args[1] = {NULL}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("toString", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((QString*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QHttpHeader::toString(); | ||
florianlink
|
r99 | } | ||
QHttpHeader* PythonQtWrapper_QHttpHeader::new_QHttpHeader() | ||||
{ | ||||
return new PythonQtShell_QHttpHeader(); } | ||||
QHttpHeader* PythonQtWrapper_QHttpHeader::new_QHttpHeader(const QString& str) | ||||
{ | ||||
return new PythonQtShell_QHttpHeader(str); } | ||||
florianlink
|
r128 | void PythonQtWrapper_QHttpHeader::addValue(QHttpHeader* theWrappedObject, const QString& key, const QString& value) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | ( theWrappedObject->addValue(key, value)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | QStringList PythonQtWrapper_QHttpHeader::allValues(QHttpHeader* theWrappedObject, const QString& key) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->allValues(key)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | uint PythonQtWrapper_QHttpHeader::contentLength(QHttpHeader* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->contentLength()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QString PythonQtWrapper_QHttpHeader::contentType(QHttpHeader* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->contentType()); | ||
florianlink
|
r99 | } | ||
bool PythonQtWrapper_QHttpHeader::hasContentLength(QHttpHeader* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->hasContentLength()); | ||||
} | ||||
bool PythonQtWrapper_QHttpHeader::hasContentType(QHttpHeader* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->hasContentType()); | ||||
} | ||||
florianlink
|
r128 | bool PythonQtWrapper_QHttpHeader::hasKey(QHttpHeader* theWrappedObject, const QString& key) const | ||
{ | ||||
return ( theWrappedObject->hasKey(key)); | ||||
} | ||||
bool PythonQtWrapper_QHttpHeader::isValid(QHttpHeader* theWrappedObject) const | ||||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->isValid()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QStringList PythonQtWrapper_QHttpHeader::keys(QHttpHeader* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->keys()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QHttpHeader::parseLine(QHttpHeader* theWrappedObject, const QString& line, int number) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QHttpHeader*)theWrappedObject)->promoted_parseLine(line, number)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QHttpHeader::removeAllValues(QHttpHeader* theWrappedObject, const QString& key) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( theWrappedObject->removeAllValues(key)); | ||
florianlink
|
r99 | } | ||
void PythonQtWrapper_QHttpHeader::removeValue(QHttpHeader* theWrappedObject, const QString& key) | ||||
{ | ||||
( theWrappedObject->removeValue(key)); | ||||
} | ||||
florianlink
|
r128 | void PythonQtWrapper_QHttpHeader::setContentLength(QHttpHeader* theWrappedObject, int len) | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | ( theWrappedObject->setContentLength(len)); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QHttpHeader::setContentType(QHttpHeader* theWrappedObject, const QString& type) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( theWrappedObject->setContentType(type)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QHttpHeader::setValue(QHttpHeader* theWrappedObject, const QString& key, const QString& value) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( theWrappedObject->setValue(key, value)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QHttpHeader::setValues(QHttpHeader* theWrappedObject, const QList<QPair<QString , QString > >& values) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( theWrappedObject->setValues(values)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QString PythonQtWrapper_QHttpHeader::toString(QHttpHeader* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QHttpHeader*)theWrappedObject)->promoted_toString()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QString PythonQtWrapper_QHttpHeader::value(QHttpHeader* theWrappedObject, const QString& key) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->value(key)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QList<QPair<QString , QString > > PythonQtWrapper_QHttpHeader::values(QHttpHeader* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->values()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r117 | QString PythonQtWrapper_QHttpHeader::py_toString(QHttpHeader* obj) { return obj->toString(); } | ||
florianlink
|
r99 | |||
florianlink
|
r186 | PythonQtShell_QHttpMultiPart::~PythonQtShell_QHttpMultiPart() { | ||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
void PythonQtShell_QHttpMultiPart::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; | ||||
} | ||||
} | ||||
QHttpMultiPart::childEvent(arg__1); | ||||
} | ||||
void PythonQtShell_QHttpMultiPart::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; | ||||
} | ||||
} | ||||
QHttpMultiPart::customEvent(arg__1); | ||||
} | ||||
bool PythonQtShell_QHttpMultiPart::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 QHttpMultiPart::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QHttpMultiPart::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 QHttpMultiPart::eventFilter(arg__1, arg__2); | ||||
} | ||||
void PythonQtShell_QHttpMultiPart::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; | ||||
} | ||||
} | ||||
QHttpMultiPart::timerEvent(arg__1); | ||||
} | ||||
QHttpMultiPart* PythonQtWrapper_QHttpMultiPart::new_QHttpMultiPart(QHttpMultiPart::ContentType contentType, QObject* parent) | ||||
{ | ||||
return new PythonQtShell_QHttpMultiPart(contentType, parent); } | ||||
QHttpMultiPart* PythonQtWrapper_QHttpMultiPart::new_QHttpMultiPart(QObject* parent) | ||||
{ | ||||
return new PythonQtShell_QHttpMultiPart(parent); } | ||||
void PythonQtWrapper_QHttpMultiPart::append(QHttpMultiPart* theWrappedObject, const QHttpPart& httpPart) | ||||
{ | ||||
( theWrappedObject->append(httpPart)); | ||||
} | ||||
QByteArray PythonQtWrapper_QHttpMultiPart::boundary(QHttpMultiPart* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->boundary()); | ||||
} | ||||
void PythonQtWrapper_QHttpMultiPart::setBoundary(QHttpMultiPart* theWrappedObject, const QByteArray& boundary) | ||||
{ | ||||
( theWrappedObject->setBoundary(boundary)); | ||||
} | ||||
void PythonQtWrapper_QHttpMultiPart::setContentType(QHttpMultiPart* theWrappedObject, QHttpMultiPart::ContentType contentType) | ||||
{ | ||||
( theWrappedObject->setContentType(contentType)); | ||||
} | ||||
QHttpPart* PythonQtWrapper_QHttpPart::new_QHttpPart() | ||||
{ | ||||
return new QHttpPart(); } | ||||
QHttpPart* PythonQtWrapper_QHttpPart::new_QHttpPart(const QHttpPart& other) | ||||
{ | ||||
return new QHttpPart(other); } | ||||
bool PythonQtWrapper_QHttpPart::__ne__(QHttpPart* theWrappedObject, const QHttpPart& other) const | ||||
{ | ||||
return ( (*theWrappedObject)!= other); | ||||
} | ||||
QHttpPart* PythonQtWrapper_QHttpPart::operator_assign(QHttpPart* theWrappedObject, const QHttpPart& other) | ||||
{ | ||||
return &( (*theWrappedObject)= other); | ||||
} | ||||
bool PythonQtWrapper_QHttpPart::__eq__(QHttpPart* theWrappedObject, const QHttpPart& other) const | ||||
{ | ||||
return ( (*theWrappedObject)== other); | ||||
} | ||||
void PythonQtWrapper_QHttpPart::setBody(QHttpPart* theWrappedObject, const QByteArray& body) | ||||
{ | ||||
( theWrappedObject->setBody(body)); | ||||
} | ||||
void PythonQtWrapper_QHttpPart::setBodyDevice(QHttpPart* theWrappedObject, QIODevice* device) | ||||
{ | ||||
( theWrappedObject->setBodyDevice(device)); | ||||
} | ||||
void PythonQtWrapper_QHttpPart::setHeader(QHttpPart* theWrappedObject, QNetworkRequest::KnownHeaders header, const QVariant& value) | ||||
{ | ||||
( theWrappedObject->setHeader(header, value)); | ||||
} | ||||
void PythonQtWrapper_QHttpPart::setRawHeader(QHttpPart* theWrappedObject, const QByteArray& headerName, const QByteArray& headerValue) | ||||
{ | ||||
( theWrappedObject->setRawHeader(headerName, headerValue)); | ||||
} | ||||
PythonQtShell_QHttpRequestHeader::~PythonQtShell_QHttpRequestHeader() { | ||||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
florianlink
|
r128 | int PythonQtShell_QHttpRequestHeader::majorVersion() const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "majorVersion"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"int"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
int returnValue; | ||||
void* args[1] = {NULL}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("majorVersion", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((int*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QHttpRequestHeader::majorVersion(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | int PythonQtShell_QHttpRequestHeader::minorVersion() const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "minorVersion"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"int"}; | ||
florianlink
|
r99 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||
florianlink
|
r128 | int returnValue; | ||
florianlink
|
r99 | 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) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("minorVersion", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((int*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QHttpRequestHeader::minorVersion(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtShell_QHttpRequestHeader::parseLine(const QString& line, int number) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "parseLine"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"bool" , "const QString&" , "int"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
bool returnValue; | ||||
void* args[3] = {NULL, (void*)&line, (void*)&number}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("parseLine", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((bool*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QHttpRequestHeader::parseLine(line, number); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QString PythonQtShell_QHttpRequestHeader::toString() const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toString"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"QString"}; | ||
florianlink
|
r99 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||
florianlink
|
r128 | QString returnValue; | ||
florianlink
|
r99 | 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) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("toString", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((QString*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QHttpRequestHeader::toString(); | ||
florianlink
|
r99 | } | ||
QHttpRequestHeader* PythonQtWrapper_QHttpRequestHeader::new_QHttpRequestHeader() | ||||
{ | ||||
return new PythonQtShell_QHttpRequestHeader(); } | ||||
QHttpRequestHeader* PythonQtWrapper_QHttpRequestHeader::new_QHttpRequestHeader(const QHttpRequestHeader& header) | ||||
{ | ||||
return new PythonQtShell_QHttpRequestHeader(header); } | ||||
QHttpRequestHeader* PythonQtWrapper_QHttpRequestHeader::new_QHttpRequestHeader(const QString& method, const QString& path, int majorVer, int minorVer) | ||||
{ | ||||
return new PythonQtShell_QHttpRequestHeader(method, path, majorVer, minorVer); } | ||||
QHttpRequestHeader* PythonQtWrapper_QHttpRequestHeader::new_QHttpRequestHeader(const QString& str) | ||||
{ | ||||
return new PythonQtShell_QHttpRequestHeader(str); } | ||||
florianlink
|
r128 | int PythonQtWrapper_QHttpRequestHeader::majorVersion(QHttpRequestHeader* theWrappedObject) const | ||
{ | ||||
return ( ((PythonQtPublicPromoter_QHttpRequestHeader*)theWrappedObject)->promoted_majorVersion()); | ||||
} | ||||
florianlink
|
r99 | QString PythonQtWrapper_QHttpRequestHeader::method(QHttpRequestHeader* theWrappedObject) const | ||
{ | ||||
return ( theWrappedObject->method()); | ||||
} | ||||
florianlink
|
r128 | int PythonQtWrapper_QHttpRequestHeader::minorVersion(QHttpRequestHeader* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QHttpRequestHeader*)theWrappedObject)->promoted_minorVersion()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QHttpRequestHeader::parseLine(QHttpRequestHeader* theWrappedObject, const QString& line, int number) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QHttpRequestHeader*)theWrappedObject)->promoted_parseLine(line, number)); | ||
florianlink
|
r99 | } | ||
QString PythonQtWrapper_QHttpRequestHeader::path(QHttpRequestHeader* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->path()); | ||||
} | ||||
void PythonQtWrapper_QHttpRequestHeader::setRequest(QHttpRequestHeader* theWrappedObject, const QString& method, const QString& path, int majorVer, int minorVer) | ||||
{ | ||||
( theWrappedObject->setRequest(method, path, majorVer, minorVer)); | ||||
} | ||||
florianlink
|
r128 | QString PythonQtWrapper_QHttpRequestHeader::toString(QHttpRequestHeader* theWrappedObject) const | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QHttpRequestHeader*)theWrappedObject)->promoted_toString()); | ||
florianlink
|
r120 | } | ||
florianlink
|
r117 | QString PythonQtWrapper_QHttpRequestHeader::py_toString(QHttpRequestHeader* obj) { return obj->toString(); } | ||
florianlink
|
r99 | |||
florianlink
|
r186 | PythonQtShell_QHttpResponseHeader::~PythonQtShell_QHttpResponseHeader() { | ||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
florianlink
|
r128 | int PythonQtShell_QHttpResponseHeader::majorVersion() const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "majorVersion"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"int"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
int returnValue; | ||||
void* args[1] = {NULL}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("majorVersion", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((int*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QHttpResponseHeader::majorVersion(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | int PythonQtShell_QHttpResponseHeader::minorVersion() const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "minorVersion"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"int"}; | ||
florianlink
|
r99 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||
florianlink
|
r128 | int returnValue; | ||
florianlink
|
r99 | 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) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("minorVersion", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((int*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QHttpResponseHeader::minorVersion(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtShell_QHttpResponseHeader::parseLine(const QString& line, int number) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "parseLine"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"bool" , "const QString&" , "int"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
bool returnValue; | ||||
void* args[3] = {NULL, (void*)&line, (void*)&number}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("parseLine", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((bool*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QHttpResponseHeader::parseLine(line, number); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QString PythonQtShell_QHttpResponseHeader::toString() const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "toString"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"QString"}; | ||
florianlink
|
r99 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||
florianlink
|
r128 | QString returnValue; | ||
florianlink
|
r99 | 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) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("toString", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((QString*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QHttpResponseHeader::toString(); | ||
florianlink
|
r99 | } | ||
QHttpResponseHeader* PythonQtWrapper_QHttpResponseHeader::new_QHttpResponseHeader() | ||||
{ | ||||
return new PythonQtShell_QHttpResponseHeader(); } | ||||
QHttpResponseHeader* PythonQtWrapper_QHttpResponseHeader::new_QHttpResponseHeader(const QHttpResponseHeader& header) | ||||
{ | ||||
return new PythonQtShell_QHttpResponseHeader(header); } | ||||
QHttpResponseHeader* PythonQtWrapper_QHttpResponseHeader::new_QHttpResponseHeader(const QString& str) | ||||
{ | ||||
return new PythonQtShell_QHttpResponseHeader(str); } | ||||
QHttpResponseHeader* PythonQtWrapper_QHttpResponseHeader::new_QHttpResponseHeader(int code, const QString& text, int majorVer, int minorVer) | ||||
{ | ||||
return new PythonQtShell_QHttpResponseHeader(code, text, majorVer, minorVer); } | ||||
florianlink
|
r128 | int PythonQtWrapper_QHttpResponseHeader::majorVersion(QHttpResponseHeader* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QHttpResponseHeader*)theWrappedObject)->promoted_majorVersion()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | int PythonQtWrapper_QHttpResponseHeader::minorVersion(QHttpResponseHeader* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QHttpResponseHeader*)theWrappedObject)->promoted_minorVersion()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QHttpResponseHeader::parseLine(QHttpResponseHeader* theWrappedObject, const QString& line, int number) | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QHttpResponseHeader*)theWrappedObject)->promoted_parseLine(line, number)); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | QString PythonQtWrapper_QHttpResponseHeader::reasonPhrase(QHttpResponseHeader* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->reasonPhrase()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QHttpResponseHeader::setStatusLine(QHttpResponseHeader* theWrappedObject, int code, const QString& text, int majorVer, int minorVer) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( theWrappedObject->setStatusLine(code, text, majorVer, minorVer)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | int PythonQtWrapper_QHttpResponseHeader::statusCode(QHttpResponseHeader* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->statusCode()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QString PythonQtWrapper_QHttpResponseHeader::toString(QHttpResponseHeader* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QHttpResponseHeader*)theWrappedObject)->promoted_toString()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r117 | QString PythonQtWrapper_QHttpResponseHeader::py_toString(QHttpResponseHeader* obj) { return obj->toString(); } | ||
florianlink
|
r99 | |||
florianlink
|
r186 | PythonQtShell_QIPv6Address::~PythonQtShell_QIPv6Address() { | ||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
florianlink
|
r99 | QIPv6Address* PythonQtWrapper_QIPv6Address::new_QIPv6Address() | ||
florianlink
|
r128 | { | ||
return new PythonQtShell_QIPv6Address(); } | ||||
florianlink
|
r186 | PythonQtShell_QLocalServer::~PythonQtShell_QLocalServer() { | ||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
florianlink
|
r128 | void PythonQtShell_QLocalServer::childEvent(QChildEvent* arg__1) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "QChildEvent*"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
florianlink
|
r128 | return; | ||
florianlink
|
r99 | } | ||
} | ||||
florianlink
|
r128 | QLocalServer::childEvent(arg__1); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtShell_QLocalServer::customEvent(QEvent* arg__1) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "QEvent*"}; | ||
florianlink
|
r99 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r128 | void* args[2] = {NULL, (void*)&arg__1}; | ||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r128 | QLocalServer::customEvent(arg__1); | ||
florianlink
|
r99 | } | ||
florianlink
|
r120 | bool PythonQtShell_QLocalServer::event(QEvent* arg__1) | ||
florianlink
|
r117 | { | ||
if (_wrapper) { | ||||
florianlink
|
r120 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event"); | ||
florianlink
|
r117 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r120 | static const char* argumentList[] ={"bool" , "QEvent*"}; | ||
florianlink
|
r117 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r120 | bool returnValue; | ||
florianlink
|
r117 | void* args[2] = {NULL, (void*)&arg__1}; | ||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
florianlink
|
r120 | if (result) { | ||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
florianlink
|
r117 | if (result) { Py_DECREF(result); } | ||
Py_DECREF(obj); | ||||
florianlink
|
r120 | return returnValue; | ||
florianlink
|
r117 | } | ||
} | ||||
florianlink
|
r120 | return QLocalServer::event(arg__1); | ||
florianlink
|
r117 | } | ||
florianlink
|
r120 | bool PythonQtShell_QLocalServer::eventFilter(QObject* arg__1, QEvent* arg__2) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r120 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r120 | static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
bool returnValue; | ||||
void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
florianlink
|
r120 | if (result) { | ||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
florianlink
|
r99 | if (result) { Py_DECREF(result); } | ||
Py_DECREF(obj); | ||||
florianlink
|
r120 | return returnValue; | ||
florianlink
|
r99 | } | ||
} | ||||
florianlink
|
r120 | return QLocalServer::eventFilter(arg__1, arg__2); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtShell_QLocalServer::hasPendingConnections() const | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasPendingConnections"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"bool"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
bool returnValue; | ||||
void* args[1] = {NULL}; | ||||
florianlink
|
r110 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
florianlink
|
r128 | if (result) { | ||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("hasPendingConnections", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
florianlink
|
r110 | if (result) { Py_DECREF(result); } | ||
Py_DECREF(obj); | ||||
florianlink
|
r128 | return returnValue; | ||
florianlink
|
r110 | } | ||
} | ||||
florianlink
|
r128 | return QLocalServer::hasPendingConnections(); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtShell_QLocalServer::incomingConnection(quintptr socketDescriptor) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "incomingConnection"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "quintptr"}; | ||
florianlink
|
r99 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r128 | void* args[2] = {NULL, (void*)&socketDescriptor}; | ||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
florianlink
|
r120 | return; | ||
florianlink
|
r99 | } | ||
} | ||||
florianlink
|
r128 | 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(); | ||||
florianlink
|
r99 | } | ||
florianlink
|
r120 | void PythonQtShell_QLocalServer::timerEvent(QTimerEvent* arg__1) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r120 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r120 | static const char* argumentList[] ={"" , "QTimerEvent*"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
florianlink
|
r120 | return; | ||
florianlink
|
r99 | } | ||
} | ||||
florianlink
|
r120 | QLocalServer::timerEvent(arg__1); | ||
florianlink
|
r99 | } | ||
QLocalServer* PythonQtWrapper_QLocalServer::new_QLocalServer(QObject* parent) | ||||
{ | ||||
return new PythonQtShell_QLocalServer(parent); } | ||||
florianlink
|
r128 | void PythonQtWrapper_QLocalServer::close(QLocalServer* theWrappedObject) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( theWrappedObject->close()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QString PythonQtWrapper_QLocalServer::errorString(QLocalServer* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->errorString()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QString PythonQtWrapper_QLocalServer::fullServerName(QLocalServer* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->fullServerName()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QLocalServer::hasPendingConnections(QLocalServer* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QLocalServer*)theWrappedObject)->promoted_hasPendingConnections()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QLocalServer::incomingConnection(QLocalServer* theWrappedObject, quintptr socketDescriptor) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( ((PythonQtPublicPromoter_QLocalServer*)theWrappedObject)->promoted_incomingConnection(socketDescriptor)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QLocalServer::isListening(QLocalServer* theWrappedObject) const | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | return ( theWrappedObject->isListening()); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QLocalServer::listen(QLocalServer* theWrappedObject, const QString& name) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->listen(name)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | int PythonQtWrapper_QLocalServer::maxPendingConnections(QLocalServer* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->maxPendingConnections()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QLocalSocket* PythonQtWrapper_QLocalServer::nextPendingConnection(QLocalServer* theWrappedObject) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QLocalServer*)theWrappedObject)->promoted_nextPendingConnection()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QLocalServer::static_QLocalServer_removeServer(const QString& name) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return (QLocalServer::removeServer(name)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QAbstractSocket::SocketError PythonQtWrapper_QLocalServer::serverError(QLocalServer* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->serverError()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QString PythonQtWrapper_QLocalServer::serverName(QLocalServer* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->serverName()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QLocalServer::setMaxPendingConnections(QLocalServer* theWrappedObject, int numConnections) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( theWrappedObject->setMaxPendingConnections(numConnections)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QLocalServer::waitForNewConnection(QLocalServer* theWrappedObject, int msec, bool* timedOut) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->waitForNewConnection(msec, timedOut)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r186 | PythonQtShell_QLocalSocket::~PythonQtShell_QLocalSocket() { | ||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
florianlink
|
r128 | bool PythonQtShell_QLocalSocket::atEnd() const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "atEnd"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"bool"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
florianlink
|
r110 | bool returnValue; | ||
florianlink
|
r128 | void* args[1] = {NULL}; | ||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("atEnd", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r110 | returnValue = *((bool*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QLocalSocket::atEnd(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | qint64 PythonQtShell_QLocalSocket::bytesAvailable() const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "bytesAvailable"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"qint64"}; | ||
florianlink
|
r99 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||
florianlink
|
r128 | qint64 returnValue; | ||
florianlink
|
r99 | void* args[1] = {NULL}; | ||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
florianlink
|
r110 | if (result) { | ||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("bytesAvailable", methodInfo, result); | ||
florianlink
|
r110 | } else { | ||
florianlink
|
r128 | returnValue = *((qint64*)args[0]); | ||
florianlink
|
r110 | } | ||
} | ||||
} | ||||
florianlink
|
r99 | if (result) { Py_DECREF(result); } | ||
Py_DECREF(obj); | ||||
florianlink
|
r110 | return returnValue; | ||
florianlink
|
r99 | } | ||
} | ||||
florianlink
|
r128 | return QLocalSocket::bytesAvailable(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | qint64 PythonQtShell_QLocalSocket::bytesToWrite() const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "bytesToWrite"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"qint64"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
qint64 returnValue; | ||||
void* args[1] = {NULL}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("bytesToWrite", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((qint64*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QLocalSocket::bytesToWrite(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtShell_QLocalSocket::canReadLine() const | ||
florianlink
|
r120 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "canReadLine"); | ||
florianlink
|
r120 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"bool"}; | ||
florianlink
|
r120 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||
florianlink
|
r128 | bool returnValue; | ||
florianlink
|
r120 | void* args[1] = {NULL}; | ||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
florianlink
|
r128 | if (result) { | ||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("canReadLine", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
florianlink
|
r120 | if (result) { Py_DECREF(result); } | ||
Py_DECREF(obj); | ||||
florianlink
|
r128 | return returnValue; | ||
florianlink
|
r120 | } | ||
} | ||||
florianlink
|
r128 | return QLocalSocket::canReadLine(); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | void PythonQtShell_QLocalSocket::childEvent(QChildEvent* arg__1) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "QChildEvent*"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
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}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
florianlink
|
r128 | return; | ||
florianlink
|
r99 | } | ||
} | ||||
florianlink
|
r128 | QLocalSocket::close(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtShell_QLocalSocket::customEvent(QEvent* arg__1) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "QEvent*"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
florianlink
|
r128 | return; | ||
florianlink
|
r99 | } | ||
} | ||||
florianlink
|
r128 | QLocalSocket::customEvent(arg__1); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtShell_QLocalSocket::event(QEvent* arg__1) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"bool" , "QEvent*"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((bool*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QLocalSocket::event(arg__1); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtShell_QLocalSocket::eventFilter(QObject* arg__1, QEvent* arg__2) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
florianlink
|
r120 | bool returnValue; | ||
florianlink
|
r128 | void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2}; | ||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r120 | returnValue = *((bool*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QLocalSocket::eventFilter(arg__1, arg__2); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtShell_QLocalSocket::isSequential() const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isSequential"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"bool"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
bool returnValue; | ||||
void* args[1] = {NULL}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("isSequential", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((bool*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QLocalSocket::isSequential(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtShell_QLocalSocket::open(QIODevice::OpenMode mode) | ||
florianlink
|
r117 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "open"); | ||
florianlink
|
r117 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"bool" , "QIODevice::OpenMode"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
florianlink
|
r120 | bool returnValue; | ||
florianlink
|
r128 | void* args[2] = {NULL, (void*)&mode}; | ||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("open", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r120 | returnValue = *((bool*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QLocalSocket::open(mode); | ||
florianlink
|
r99 | } | ||
florianlink
|
r117 | qint64 PythonQtShell_QLocalSocket::pos() const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r117 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "pos"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r117 | static const char* argumentList[] ={"qint64"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
qint64 returnValue; | ||||
void* args[1] = {NULL}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r117 | PythonQt::priv()->handleVirtualOverloadReturnError("pos", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r117 | returnValue = *((qint64*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r117 | return QLocalSocket::pos(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | qint64 PythonQtShell_QLocalSocket::readData(char* arg__1, qint64 arg__2) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "readData"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | 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}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("readData", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((qint64*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QLocalSocket::readData(arg__1, arg__2); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | qint64 PythonQtShell_QLocalSocket::readLineData(char* data, qint64 maxlen) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "readLineData"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | 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}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("readLineData", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((qint64*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QLocalSocket::readLineData(data, maxlen); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtShell_QLocalSocket::reset() | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reset"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"bool"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
bool returnValue; | ||||
void* args[1] = {NULL}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("reset", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((bool*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QLocalSocket::reset(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtShell_QLocalSocket::seek(qint64 pos) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "seek"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"bool" , "qint64"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
florianlink
|
r117 | bool returnValue; | ||
florianlink
|
r128 | void* args[2] = {NULL, (void*)&pos}; | ||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
florianlink
|
r117 | if (result) { | ||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("seek", methodInfo, result); | ||
florianlink
|
r117 | } else { | ||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
florianlink
|
r99 | if (result) { Py_DECREF(result); } | ||
Py_DECREF(obj); | ||||
florianlink
|
r117 | return returnValue; | ||
florianlink
|
r99 | } | ||
} | ||||
florianlink
|
r128 | return QLocalSocket::seek(pos); | ||
florianlink
|
r99 | } | ||
florianlink
|
r120 | qint64 PythonQtShell_QLocalSocket::size() const | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r120 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "size"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r120 | static const char* argumentList[] ={"qint64"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
florianlink
|
r117 | qint64 returnValue; | ||
florianlink
|
r120 | void* args[1] = {NULL}; | ||
florianlink
|
r117 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r120 | PythonQt::priv()->handleVirtualOverloadReturnError("size", methodInfo, result); | ||
florianlink
|
r117 | } else { | ||
returnValue = *((qint64*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r120 | return QLocalSocket::size(); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtShell_QLocalSocket::timerEvent(QTimerEvent* arg__1) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "QTimerEvent*"}; | ||
florianlink
|
r99 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
florianlink
|
r128 | return; | ||
florianlink
|
r99 | } | ||
} | ||||
florianlink
|
r128 | QLocalSocket::timerEvent(arg__1); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtShell_QLocalSocket::waitForBytesWritten(int msecs) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "waitForBytesWritten"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"bool" , "int"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
florianlink
|
r99 | bool returnValue; | ||
florianlink
|
r128 | void* args[2] = {NULL, (void*)&msecs}; | ||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("waitForBytesWritten", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QLocalSocket::waitForBytesWritten(msecs); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | bool PythonQtShell_QLocalSocket::waitForReadyRead(int msecs) | ||
florianlink
|
r120 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "waitForReadyRead"); | ||
florianlink
|
r120 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"bool" , "int"}; | ||
florianlink
|
r120 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r128 | bool returnValue; | ||
void* args[2] = {NULL, (void*)&msecs}; | ||||
florianlink
|
r120 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
florianlink
|
r128 | if (result) { | ||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("waitForReadyRead", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
florianlink
|
r120 | if (result) { Py_DECREF(result); } | ||
Py_DECREF(obj); | ||||
florianlink
|
r128 | return returnValue; | ||
florianlink
|
r120 | } | ||
} | ||||
florianlink
|
r128 | return QLocalSocket::waitForReadyRead(msecs); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | qint64 PythonQtShell_QLocalSocket::writeData(const char* arg__1, qint64 arg__2) | ||
florianlink
|
r120 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "writeData"); | ||
florianlink
|
r120 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | 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}; | ||||
florianlink
|
r120 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
florianlink
|
r128 | if (result) { | ||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("writeData", methodInfo, result); | ||||
} else { | ||||
returnValue = *((qint64*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
florianlink
|
r120 | if (result) { Py_DECREF(result); } | ||
Py_DECREF(obj); | ||||
florianlink
|
r128 | return returnValue; | ||
florianlink
|
r120 | } | ||
} | ||||
florianlink
|
r128 | return QLocalSocket::writeData(arg__1, arg__2); | ||
florianlink
|
r120 | } | ||
florianlink
|
r99 | QLocalSocket* PythonQtWrapper_QLocalSocket::new_QLocalSocket(QObject* parent) | ||
{ | ||||
return new PythonQtShell_QLocalSocket(parent); } | ||||
florianlink
|
r128 | void PythonQtWrapper_QLocalSocket::abort(QLocalSocket* theWrappedObject) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( theWrappedObject->abort()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | qint64 PythonQtWrapper_QLocalSocket::bytesAvailable(QLocalSocket* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QLocalSocket*)theWrappedObject)->promoted_bytesAvailable()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | qint64 PythonQtWrapper_QLocalSocket::bytesToWrite(QLocalSocket* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QLocalSocket*)theWrappedObject)->promoted_bytesToWrite()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QLocalSocket::canReadLine(QLocalSocket* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QLocalSocket*)theWrappedObject)->promoted_canReadLine()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QLocalSocket::close(QLocalSocket* theWrappedObject) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( ((PythonQtPublicPromoter_QLocalSocket*)theWrappedObject)->promoted_close()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QLocalSocket::connectToServer(QLocalSocket* theWrappedObject, const QString& name, QIODevice::OpenMode openMode) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( theWrappedObject->connectToServer(name, openMode)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QLocalSocket::disconnectFromServer(QLocalSocket* theWrappedObject) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( theWrappedObject->disconnectFromServer()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QLocalSocket::LocalSocketError PythonQtWrapper_QLocalSocket::error(QLocalSocket* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->error()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QLocalSocket::flush(QLocalSocket* theWrappedObject) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->flush()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QString PythonQtWrapper_QLocalSocket::fullServerName(QLocalSocket* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->fullServerName()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QLocalSocket::isSequential(QLocalSocket* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QLocalSocket*)theWrappedObject)->promoted_isSequential()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QLocalSocket::isValid(QLocalSocket* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->isValid()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | qint64 PythonQtWrapper_QLocalSocket::readBufferSize(QLocalSocket* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->readBufferSize()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | qint64 PythonQtWrapper_QLocalSocket::readData(QLocalSocket* theWrappedObject, char* arg__1, qint64 arg__2) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QLocalSocket*)theWrappedObject)->promoted_readData(arg__1, arg__2)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | QString PythonQtWrapper_QLocalSocket::serverName(QLocalSocket* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->serverName()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QLocalSocket::setReadBufferSize(QLocalSocket* theWrappedObject, qint64 size) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( theWrappedObject->setReadBufferSize(size)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QLocalSocket::setSocketDescriptor(QLocalSocket* theWrappedObject, quintptr socketDescriptor, QLocalSocket::LocalSocketState socketState, QIODevice::OpenMode openMode) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->setSocketDescriptor(socketDescriptor, socketState, openMode)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r120 | quintptr PythonQtWrapper_QLocalSocket::socketDescriptor(QLocalSocket* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r120 | return ( theWrappedObject->socketDescriptor()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QLocalSocket::LocalSocketState PythonQtWrapper_QLocalSocket::state(QLocalSocket* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->state()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QLocalSocket::waitForBytesWritten(QLocalSocket* theWrappedObject, int msecs) | ||
florianlink
|
r117 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QLocalSocket*)theWrappedObject)->promoted_waitForBytesWritten(msecs)); | ||
florianlink
|
r117 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QLocalSocket::waitForConnected(QLocalSocket* theWrappedObject, int msecs) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->waitForConnected(msecs)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QLocalSocket::waitForDisconnected(QLocalSocket* theWrappedObject, int msecs) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->waitForDisconnected(msecs)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QLocalSocket::waitForReadyRead(QLocalSocket* theWrappedObject, int msecs) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QLocalSocket*)theWrappedObject)->promoted_waitForReadyRead(msecs)); | ||
florianlink
|
r117 | } | ||
florianlink
|
r128 | qint64 PythonQtWrapper_QLocalSocket::writeData(QLocalSocket* theWrappedObject, const char* arg__1, qint64 arg__2) | ||
florianlink
|
r117 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QLocalSocket*)theWrappedObject)->promoted_writeData(arg__1, arg__2)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r186 | PythonQtShell_QNetworkAccessManager::~PythonQtShell_QNetworkAccessManager() { | ||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
florianlink
|
r128 | 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); | ||||
} | ||||
florianlink
|
r99 | 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); | ||||
} | ||||
florianlink
|
r128 | 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); | ||||
} | ||||
florianlink
|
r110 | bool PythonQtShell_QNetworkAccessManager::event(QEvent* arg__1) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r110 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r110 | static const char* argumentList[] ={"bool" , "QEvent*"}; | ||
florianlink
|
r99 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r110 | bool returnValue; | ||
florianlink
|
r99 | void* args[2] = {NULL, (void*)&arg__1}; | ||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
florianlink
|
r110 | if (result) { | ||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
florianlink
|
r99 | if (result) { Py_DECREF(result); } | ||
Py_DECREF(obj); | ||||
florianlink
|
r110 | return returnValue; | ||
florianlink
|
r99 | } | ||
} | ||||
florianlink
|
r110 | return QNetworkAccessManager::event(arg__1); | ||
florianlink
|
r99 | } | ||
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); | ||||
} | ||||
florianlink
|
r120 | 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); } | ||||
florianlink
|
r99 | |||
florianlink
|
r128 | QAbstractNetworkCache* PythonQtWrapper_QNetworkAccessManager::cache(QNetworkAccessManager* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->cache()); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | QNetworkCookieJar* PythonQtWrapper_QNetworkAccessManager::cookieJar(QNetworkAccessManager* theWrappedObject) const | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | return ( theWrappedObject->cookieJar()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QNetworkReply* PythonQtWrapper_QNetworkAccessManager::createRequest(QNetworkAccessManager* theWrappedObject, QNetworkAccessManager::Operation op, const QNetworkRequest& request, QIODevice* outgoingData) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QNetworkAccessManager*)theWrappedObject)->promoted_createRequest(op, request, outgoingData)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | QNetworkReply* PythonQtWrapper_QNetworkAccessManager::deleteResource(QNetworkAccessManager* theWrappedObject, const QNetworkRequest& request) | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | return ( theWrappedObject->deleteResource(request)); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | QNetworkReply* PythonQtWrapper_QNetworkAccessManager::get(QNetworkAccessManager* theWrappedObject, const QNetworkRequest& request) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->get(request)); | ||
florianlink
|
r99 | } | ||
QNetworkReply* PythonQtWrapper_QNetworkAccessManager::head(QNetworkAccessManager* theWrappedObject, const QNetworkRequest& request) | ||||
{ | ||||
return ( theWrappedObject->head(request)); | ||||
} | ||||
florianlink
|
r186 | QNetworkAccessManager::NetworkAccessibility PythonQtWrapper_QNetworkAccessManager::networkAccessible(QNetworkAccessManager* theWrappedObject) const | ||
{ | ||||
return ( theWrappedObject->networkAccessible()); | ||||
} | ||||
QNetworkReply* PythonQtWrapper_QNetworkAccessManager::post(QNetworkAccessManager* theWrappedObject, const QNetworkRequest& request, QHttpMultiPart* multiPart) | ||||
{ | ||||
return ( theWrappedObject->post(request, multiPart)); | ||||
} | ||||
florianlink
|
r128 | QNetworkReply* PythonQtWrapper_QNetworkAccessManager::post(QNetworkAccessManager* theWrappedObject, const QNetworkRequest& request, QIODevice* data) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->post(request, data)); | ||
florianlink
|
r99 | } | ||
QNetworkReply* PythonQtWrapper_QNetworkAccessManager::post(QNetworkAccessManager* theWrappedObject, const QNetworkRequest& request, const QByteArray& data) | ||||
{ | ||||
return ( theWrappedObject->post(request, data)); | ||||
} | ||||
florianlink
|
r128 | QNetworkProxy PythonQtWrapper_QNetworkAccessManager::proxy(QNetworkAccessManager* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->proxy()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QNetworkProxyFactory* PythonQtWrapper_QNetworkAccessManager::proxyFactory(QNetworkAccessManager* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->proxyFactory()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r186 | QNetworkReply* PythonQtWrapper_QNetworkAccessManager::put(QNetworkAccessManager* theWrappedObject, const QNetworkRequest& request, QHttpMultiPart* multiPart) | ||
{ | ||||
return ( theWrappedObject->put(request, multiPart)); | ||||
} | ||||
florianlink
|
r128 | QNetworkReply* PythonQtWrapper_QNetworkAccessManager::put(QNetworkAccessManager* theWrappedObject, const QNetworkRequest& request, QIODevice* data) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->put(request, data)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r120 | QNetworkReply* PythonQtWrapper_QNetworkAccessManager::put(QNetworkAccessManager* theWrappedObject, const QNetworkRequest& request, const QByteArray& data) | ||
florianlink
|
r99 | { | ||
florianlink
|
r110 | return ( theWrappedObject->put(request, data)); | ||
} | ||||
florianlink
|
r186 | QNetworkReply* PythonQtWrapper_QNetworkAccessManager::sendCustomRequest(QNetworkAccessManager* theWrappedObject, const QNetworkRequest& request, const QByteArray& verb, QIODevice* data) | ||
{ | ||||
return ( theWrappedObject->sendCustomRequest(request, verb, data)); | ||||
} | ||||
florianlink
|
r128 | void PythonQtWrapper_QNetworkAccessManager::setCache(QNetworkAccessManager* theWrappedObject, QAbstractNetworkCache* cache) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | ( theWrappedObject->setCache(cache)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QNetworkAccessManager::setCookieJar(QNetworkAccessManager* theWrappedObject, QNetworkCookieJar* cookieJar) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | ( theWrappedObject->setCookieJar(cookieJar)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r186 | void PythonQtWrapper_QNetworkAccessManager::setNetworkAccessible(QNetworkAccessManager* theWrappedObject, QNetworkAccessManager::NetworkAccessibility accessible) | ||
{ | ||||
( theWrappedObject->setNetworkAccessible(accessible)); | ||||
} | ||||
florianlink
|
r128 | void PythonQtWrapper_QNetworkAccessManager::setProxy(QNetworkAccessManager* theWrappedObject, const QNetworkProxy& proxy) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | ( theWrappedObject->setProxy(proxy)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QNetworkAccessManager::setProxyFactory(QNetworkAccessManager* theWrappedObject, QNetworkProxyFactory* factory) | ||
florianlink
|
r117 | { | ||
florianlink
|
r128 | ( theWrappedObject->setProxyFactory(factory)); | ||
florianlink
|
r117 | } | ||
florianlink
|
r99 | |||
QNetworkAddressEntry* PythonQtWrapper_QNetworkAddressEntry::new_QNetworkAddressEntry() | ||||
{ | ||||
return new QNetworkAddressEntry(); } | ||||
QNetworkAddressEntry* PythonQtWrapper_QNetworkAddressEntry::new_QNetworkAddressEntry(const QNetworkAddressEntry& other) | ||||
{ | ||||
return new QNetworkAddressEntry(other); } | ||||
florianlink
|
r128 | QHostAddress PythonQtWrapper_QNetworkAddressEntry::broadcast(QNetworkAddressEntry* theWrappedObject) const | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | return ( theWrappedObject->broadcast()); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | QHostAddress PythonQtWrapper_QNetworkAddressEntry::ip(QNetworkAddressEntry* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->ip()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | QHostAddress PythonQtWrapper_QNetworkAddressEntry::netmask(QNetworkAddressEntry* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->netmask()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QNetworkAddressEntry::__ne__(QNetworkAddressEntry* theWrappedObject, const QNetworkAddressEntry& other) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( (*theWrappedObject)!= other); | ||
florianlink
|
r99 | } | ||
florianlink
|
r120 | bool PythonQtWrapper_QNetworkAddressEntry::__eq__(QNetworkAddressEntry* theWrappedObject, const QNetworkAddressEntry& other) const | ||
florianlink
|
r110 | { | ||
return ( (*theWrappedObject)== other); | ||||
florianlink
|
r99 | } | ||
florianlink
|
r128 | int PythonQtWrapper_QNetworkAddressEntry::prefixLength(QNetworkAddressEntry* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->prefixLength()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QNetworkAddressEntry::setBroadcast(QNetworkAddressEntry* theWrappedObject, const QHostAddress& newBroadcast) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | ( theWrappedObject->setBroadcast(newBroadcast)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QNetworkAddressEntry::setIp(QNetworkAddressEntry* theWrappedObject, const QHostAddress& newIp) | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | ( theWrappedObject->setIp(newIp)); | ||
florianlink
|
r120 | } | ||
florianlink
|
r99 | void PythonQtWrapper_QNetworkAddressEntry::setNetmask(QNetworkAddressEntry* theWrappedObject, const QHostAddress& newNetmask) | ||
{ | ||||
( theWrappedObject->setNetmask(newNetmask)); | ||||
} | ||||
florianlink
|
r128 | void PythonQtWrapper_QNetworkAddressEntry::setPrefixLength(QNetworkAddressEntry* theWrappedObject, int length) | ||
{ | ||||
( theWrappedObject->setPrefixLength(length)); | ||||
} | ||||
florianlink
|
r110 | |||
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 | ||||
florianlink
|
r99 | { | ||
florianlink
|
r110 | return ( theWrappedObject->attributes()); | ||
} | ||||
florianlink
|
r128 | QDateTime PythonQtWrapper_QNetworkCacheMetaData::expirationDate(QNetworkCacheMetaData* theWrappedObject) const | ||
{ | ||||
return ( theWrappedObject->expirationDate()); | ||||
} | ||||
florianlink
|
r120 | bool PythonQtWrapper_QNetworkCacheMetaData::isValid(QNetworkCacheMetaData* theWrappedObject) const | ||
{ | ||||
return ( theWrappedObject->isValid()); | ||||
} | ||||
florianlink
|
r128 | QDateTime PythonQtWrapper_QNetworkCacheMetaData::lastModified(QNetworkCacheMetaData* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->lastModified()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QNetworkCacheMetaData::__ne__(QNetworkCacheMetaData* theWrappedObject, const QNetworkCacheMetaData& other) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( (*theWrappedObject)!= other); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QNetworkCacheMetaData::writeTo(QNetworkCacheMetaData* theWrappedObject, QDataStream& arg__1) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | arg__1 << (*theWrappedObject); | ||
florianlink
|
r110 | } | ||
florianlink
|
r120 | bool PythonQtWrapper_QNetworkCacheMetaData::__eq__(QNetworkCacheMetaData* theWrappedObject, const QNetworkCacheMetaData& other) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r120 | return ( (*theWrappedObject)== other); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QNetworkCacheMetaData::readFrom(QNetworkCacheMetaData* theWrappedObject, QDataStream& arg__1) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | arg__1 >> (*theWrappedObject); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | QList<QPair<QByteArray , QByteArray > > PythonQtWrapper_QNetworkCacheMetaData::rawHeaders(QNetworkCacheMetaData* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->rawHeaders()); | ||
florianlink
|
r120 | } | ||
bool PythonQtWrapper_QNetworkCacheMetaData::saveToDisk(QNetworkCacheMetaData* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->saveToDisk()); | ||||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QNetworkCacheMetaData::setAttributes(QNetworkCacheMetaData* theWrappedObject, const QHash<QNetworkRequest::Attribute , QVariant >& attributes) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | ( theWrappedObject->setAttributes(attributes)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QNetworkCacheMetaData::setExpirationDate(QNetworkCacheMetaData* theWrappedObject, const QDateTime& dateTime) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | ( theWrappedObject->setExpirationDate(dateTime)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QNetworkCacheMetaData::setLastModified(QNetworkCacheMetaData* theWrappedObject, const QDateTime& dateTime) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | ( theWrappedObject->setLastModified(dateTime)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QNetworkCacheMetaData::setRawHeaders(QNetworkCacheMetaData* theWrappedObject, const QList<QPair<QByteArray , QByteArray > >& headers) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | ( theWrappedObject->setRawHeaders(headers)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QNetworkCacheMetaData::setSaveToDisk(QNetworkCacheMetaData* theWrappedObject, bool allow) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | ( theWrappedObject->setSaveToDisk(allow)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QNetworkCacheMetaData::setUrl(QNetworkCacheMetaData* theWrappedObject, const QUrl& url) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | ( theWrappedObject->setUrl(url)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | QUrl PythonQtWrapper_QNetworkCacheMetaData::url(QNetworkCacheMetaData* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->url()); | ||
florianlink
|
r99 | } | ||
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); } | ||||
florianlink
|
r128 | QString PythonQtWrapper_QNetworkCookie::domain(QNetworkCookie* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->domain()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QDateTime PythonQtWrapper_QNetworkCookie::expirationDate(QNetworkCookie* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->expirationDate()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QNetworkCookie::isHttpOnly(QNetworkCookie* theWrappedObject) const | ||
florianlink
|
r117 | { | ||
florianlink
|
r128 | return ( theWrappedObject->isHttpOnly()); | ||
florianlink
|
r117 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QNetworkCookie::isSecure(QNetworkCookie* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->isSecure()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QNetworkCookie::isSessionCookie(QNetworkCookie* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->isSessionCookie()); | ||
florianlink
|
r120 | } | ||
QByteArray PythonQtWrapper_QNetworkCookie::name(QNetworkCookie* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->name()); | ||||
florianlink
|
r110 | } | ||
florianlink
|
r120 | bool PythonQtWrapper_QNetworkCookie::__ne__(QNetworkCookie* theWrappedObject, const QNetworkCookie& other) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r120 | return ( (*theWrappedObject)!= other); | ||
florianlink
|
r99 | } | ||
florianlink
|
r120 | bool PythonQtWrapper_QNetworkCookie::__eq__(QNetworkCookie* theWrappedObject, const QNetworkCookie& other) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r120 | return ( (*theWrappedObject)== other); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QList<QNetworkCookie > PythonQtWrapper_QNetworkCookie::static_QNetworkCookie_parseCookies(const QByteArray& cookieString) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return (QNetworkCookie::parseCookies(cookieString)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QString PythonQtWrapper_QNetworkCookie::path(QNetworkCookie* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->path()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r120 | void PythonQtWrapper_QNetworkCookie::setDomain(QNetworkCookie* theWrappedObject, const QString& domain) | ||
florianlink
|
r99 | { | ||
florianlink
|
r120 | ( theWrappedObject->setDomain(domain)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r120 | void PythonQtWrapper_QNetworkCookie::setExpirationDate(QNetworkCookie* theWrappedObject, const QDateTime& date) | ||
florianlink
|
r99 | { | ||
florianlink
|
r120 | ( theWrappedObject->setExpirationDate(date)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QNetworkCookie::setHttpOnly(QNetworkCookie* theWrappedObject, bool enable) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( theWrappedObject->setHttpOnly(enable)); | ||
} | ||||
void PythonQtWrapper_QNetworkCookie::setName(QNetworkCookie* theWrappedObject, const QByteArray& cookieName) | ||||
{ | ||||
( theWrappedObject->setName(cookieName)); | ||||
florianlink
|
r99 | } | ||
florianlink
|
r120 | void PythonQtWrapper_QNetworkCookie::setPath(QNetworkCookie* theWrappedObject, const QString& path) | ||
florianlink
|
r99 | { | ||
florianlink
|
r120 | ( theWrappedObject->setPath(path)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QNetworkCookie::setSecure(QNetworkCookie* theWrappedObject, bool enable) | ||
{ | ||||
( theWrappedObject->setSecure(enable)); | ||||
} | ||||
void PythonQtWrapper_QNetworkCookie::setValue(QNetworkCookie* theWrappedObject, const QByteArray& value) | ||||
{ | ||||
( theWrappedObject->setValue(value)); | ||||
} | ||||
florianlink
|
r120 | QByteArray PythonQtWrapper_QNetworkCookie::toRawForm(QNetworkCookie* theWrappedObject, QNetworkCookie::RawForm form) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r120 | return ( theWrappedObject->toRawForm(form)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QByteArray PythonQtWrapper_QNetworkCookie::value(QNetworkCookie* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->value()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r117 | QString PythonQtWrapper_QNetworkCookie::py_toString(QNetworkCookie* obj) { | ||
florianlink
|
r99 | QString result; | ||
QDebug d(&result); | ||||
d << *obj; | ||||
return result; | ||||
} | ||||
florianlink
|
r186 | PythonQtShell_QNetworkCookieJar::~PythonQtShell_QNetworkCookieJar() { | ||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
florianlink
|
r128 | void PythonQtShell_QNetworkCookieJar::childEvent(QChildEvent* arg__1) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "QChildEvent*"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
florianlink
|
r128 | return; | ||
florianlink
|
r99 | } | ||
} | ||||
florianlink
|
r128 | QNetworkCookieJar::childEvent(arg__1); | ||
florianlink
|
r99 | } | ||
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); | ||||
} | ||||
florianlink
|
r128 | 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); | ||||
} | ||||
florianlink
|
r99 | 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); | ||||
} | ||||
florianlink
|
r128 | bool PythonQtShell_QNetworkCookieJar::setCookiesFromUrl(const QList<QNetworkCookie >& cookieList, const QUrl& url) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setCookiesFromUrl"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | 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*"}; | ||||
florianlink
|
r99 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r120 | void* args[2] = {NULL, (void*)&arg__1}; | ||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
florianlink
|
r120 | return; | ||
florianlink
|
r99 | } | ||
} | ||||
florianlink
|
r128 | QNetworkCookieJar::timerEvent(arg__1); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | 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::setCookiesFromUrl(QNetworkCookieJar* theWrappedObject, const QList<QNetworkCookie >& cookieList, const QUrl& url) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QNetworkCookieJar*)theWrappedObject)->promoted_setCookiesFromUrl(cookieList, url)); | ||||
} | ||||
florianlink
|
r186 | PythonQtShell_QNetworkDiskCache::~PythonQtShell_QNetworkDiskCache() { | ||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
florianlink
|
r128 | qint64 PythonQtShell_QNetworkDiskCache::cacheSize() const | ||
florianlink
|
r120 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | 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"); | ||||
florianlink
|
r120 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "QChildEvent*"}; | ||
florianlink
|
r120 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r128 | QNetworkDiskCache::childEvent(arg__1); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | void PythonQtShell_QNetworkDiskCache::clear() | ||
florianlink
|
r120 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "clear"); | ||
florianlink
|
r120 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={""}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
void* args[1] = {NULL}; | ||||
florianlink
|
r120 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r128 | QNetworkDiskCache::clear(); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | void PythonQtShell_QNetworkDiskCache::customEvent(QEvent* arg__1) | ||
florianlink
|
r120 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent"); | ||
florianlink
|
r120 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "QEvent*"}; | ||
florianlink
|
r120 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r128 | void* args[2] = {NULL, (void*)&arg__1}; | ||
florianlink
|
r120 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
florianlink
|
r128 | return; | ||
florianlink
|
r120 | } | ||
} | ||||
florianlink
|
r128 | QNetworkDiskCache::customEvent(arg__1); | ||
florianlink
|
r99 | } | ||
florianlink
|
r110 | QIODevice* PythonQtShell_QNetworkDiskCache::data(const QUrl& url) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r110 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "data"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r110 | static const char* argumentList[] ={"QIODevice*" , "const QUrl&"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QIODevice* returnValue; | ||||
void* args[2] = {NULL, (void*)&url}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r110 | PythonQt::priv()->handleVirtualOverloadReturnError("data", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r110 | returnValue = *((QIODevice**)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r110 | return QNetworkDiskCache::data(url); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtShell_QNetworkDiskCache::event(QEvent* arg__1) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"bool" , "QEvent*"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
florianlink
|
r110 | if (result) { | ||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result); | ||
florianlink
|
r110 | } else { | ||
florianlink
|
r128 | returnValue = *((bool*)args[0]); | ||
florianlink
|
r110 | } | ||
} | ||||
} | ||||
florianlink
|
r99 | if (result) { Py_DECREF(result); } | ||
Py_DECREF(obj); | ||||
florianlink
|
r110 | return returnValue; | ||
florianlink
|
r99 | } | ||
} | ||||
florianlink
|
r128 | return QNetworkDiskCache::event(arg__1); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtShell_QNetworkDiskCache::eventFilter(QObject* arg__1, QEvent* arg__2) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
bool returnValue; | ||||
void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((bool*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QNetworkDiskCache::eventFilter(arg__1, arg__2); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | qint64 PythonQtShell_QNetworkDiskCache::expire() | ||
florianlink
|
r120 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "expire"); | ||
florianlink
|
r120 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"qint64"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
qint64 returnValue; | ||||
void* args[1] = {NULL}; | ||||
florianlink
|
r120 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("expire", methodInfo, result); | ||
florianlink
|
r120 | } else { | ||
florianlink
|
r128 | returnValue = *((qint64*)args[0]); | ||
florianlink
|
r120 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QNetworkDiskCache::expire(); | ||
florianlink
|
r120 | } | ||
florianlink
|
r110 | void PythonQtShell_QNetworkDiskCache::insert(QIODevice* device) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r110 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "insert"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r110 | static const char* argumentList[] ={"" , "QIODevice*"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&device}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r110 | QNetworkDiskCache::insert(device); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QNetworkCacheMetaData PythonQtShell_QNetworkDiskCache::metaData(const QUrl& url) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "metaData"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"QNetworkCacheMetaData" , "const QUrl&"}; | ||
florianlink
|
r120 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r128 | QNetworkCacheMetaData returnValue; | ||
florianlink
|
r120 | void* args[2] = {NULL, (void*)&url}; | ||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("metaData", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((QNetworkCacheMetaData*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QNetworkDiskCache::metaData(url); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QIODevice* PythonQtShell_QNetworkDiskCache::prepare(const QNetworkCacheMetaData& metaData) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "prepare"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"QIODevice*" , "const QNetworkCacheMetaData&"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
QIODevice* returnValue; | ||||
void* args[2] = {NULL, (void*)&metaData}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("prepare", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r128 | returnValue = *((QIODevice**)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QNetworkDiskCache::prepare(metaData); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtShell_QNetworkDiskCache::remove(const QUrl& url) | ||
florianlink
|
r117 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "remove"); | ||
florianlink
|
r117 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"bool" , "const QUrl&"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
florianlink
|
r120 | bool returnValue; | ||
florianlink
|
r128 | void* args[2] = {NULL, (void*)&url}; | ||
florianlink
|
r117 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
florianlink
|
r120 | if (result) { | ||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("remove", methodInfo, result); | ||
florianlink
|
r120 | } else { | ||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
florianlink
|
r117 | if (result) { Py_DECREF(result); } | ||
Py_DECREF(obj); | ||||
florianlink
|
r120 | return returnValue; | ||
florianlink
|
r117 | } | ||
} | ||||
florianlink
|
r128 | return QNetworkDiskCache::remove(url); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtShell_QNetworkDiskCache::timerEvent(QTimerEvent* arg__1) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "QTimerEvent*"}; | ||
florianlink
|
r110 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
florianlink
|
r110 | return; | ||
florianlink
|
r99 | } | ||
} | ||||
florianlink
|
r128 | QNetworkDiskCache::timerEvent(arg__1); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtShell_QNetworkDiskCache::updateMetaData(const QNetworkCacheMetaData& metaData) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "updateMetaData"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "const QNetworkCacheMetaData&"}; | ||
florianlink
|
r99 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r128 | void* args[2] = {NULL, (void*)&metaData}; | ||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
florianlink
|
r120 | return; | ||
florianlink
|
r99 | } | ||
} | ||||
florianlink
|
r128 | QNetworkDiskCache::updateMetaData(metaData); | ||
florianlink
|
r99 | } | ||
florianlink
|
r110 | QNetworkDiskCache* PythonQtWrapper_QNetworkDiskCache::new_QNetworkDiskCache(QObject* parent) | ||
{ | ||||
return new PythonQtShell_QNetworkDiskCache(parent); } | ||||
QString PythonQtWrapper_QNetworkDiskCache::cacheDirectory(QNetworkDiskCache* theWrappedObject) const | ||||
florianlink
|
r99 | { | ||
florianlink
|
r110 | return ( theWrappedObject->cacheDirectory()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r110 | |||
florianlink
|
r128 | qint64 PythonQtWrapper_QNetworkDiskCache::cacheSize(QNetworkDiskCache* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QNetworkDiskCache*)theWrappedObject)->promoted_cacheSize()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r110 | |||
florianlink
|
r186 | void PythonQtWrapper_QNetworkDiskCache::clear(QNetworkDiskCache* theWrappedObject) | ||
{ | ||||
( ((PythonQtPublicPromoter_QNetworkDiskCache*)theWrappedObject)->promoted_clear()); | ||||
} | ||||
florianlink
|
r120 | QIODevice* PythonQtWrapper_QNetworkDiskCache::data(QNetworkDiskCache* theWrappedObject, const QUrl& url) | ||
florianlink
|
r99 | { | ||
florianlink
|
r120 | return ( ((PythonQtPublicPromoter_QNetworkDiskCache*)theWrappedObject)->promoted_data(url)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r110 | |||
florianlink
|
r128 | qint64 PythonQtWrapper_QNetworkDiskCache::expire(QNetworkDiskCache* theWrappedObject) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QNetworkDiskCache*)theWrappedObject)->promoted_expire()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r110 | |||
florianlink
|
r128 | QNetworkCacheMetaData PythonQtWrapper_QNetworkDiskCache::fileMetaData(QNetworkDiskCache* theWrappedObject, const QString& fileName) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->fileMetaData(fileName)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r110 | |||
florianlink
|
r128 | void PythonQtWrapper_QNetworkDiskCache::insert(QNetworkDiskCache* theWrappedObject, QIODevice* device) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | ( ((PythonQtPublicPromoter_QNetworkDiskCache*)theWrappedObject)->promoted_insert(device)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r110 | |||
florianlink
|
r128 | qint64 PythonQtWrapper_QNetworkDiskCache::maximumCacheSize(QNetworkDiskCache* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->maximumCacheSize()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r110 | |||
florianlink
|
r128 | QNetworkCacheMetaData PythonQtWrapper_QNetworkDiskCache::metaData(QNetworkDiskCache* theWrappedObject, const QUrl& url) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QNetworkDiskCache*)theWrappedObject)->promoted_metaData(url)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r110 | |||
florianlink
|
r128 | QIODevice* PythonQtWrapper_QNetworkDiskCache::prepare(QNetworkDiskCache* theWrappedObject, const QNetworkCacheMetaData& metaData) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QNetworkDiskCache*)theWrappedObject)->promoted_prepare(metaData)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r110 | |||
florianlink
|
r128 | bool PythonQtWrapper_QNetworkDiskCache::remove(QNetworkDiskCache* theWrappedObject, const QUrl& url) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QNetworkDiskCache*)theWrappedObject)->promoted_remove(url)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r110 | |||
florianlink
|
r128 | void PythonQtWrapper_QNetworkDiskCache::setCacheDirectory(QNetworkDiskCache* theWrappedObject, const QString& cacheDir) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( theWrappedObject->setCacheDirectory(cacheDir)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r110 | |||
florianlink
|
r128 | void PythonQtWrapper_QNetworkDiskCache::setMaximumCacheSize(QNetworkDiskCache* theWrappedObject, qint64 size) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | ( theWrappedObject->setMaximumCacheSize(size)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r110 | |||
florianlink
|
r128 | void PythonQtWrapper_QNetworkDiskCache::updateMetaData(QNetworkDiskCache* theWrappedObject, const QNetworkCacheMetaData& metaData) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( ((PythonQtPublicPromoter_QNetworkDiskCache*)theWrappedObject)->promoted_updateMetaData(metaData)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r110 | QNetworkInterface* PythonQtWrapper_QNetworkInterface::new_QNetworkInterface() | ||
{ | ||||
return new QNetworkInterface(); } | ||||
QNetworkInterface* PythonQtWrapper_QNetworkInterface::new_QNetworkInterface(const QNetworkInterface& other) | ||||
{ | ||||
return new QNetworkInterface(other); } | ||||
florianlink
|
r128 | QList<QNetworkAddressEntry > PythonQtWrapper_QNetworkInterface::addressEntries(QNetworkInterface* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->addressEntries()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QList<QHostAddress > PythonQtWrapper_QNetworkInterface::static_QNetworkInterface_allAddresses() | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return (QNetworkInterface::allAddresses()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QList<QNetworkInterface > PythonQtWrapper_QNetworkInterface::static_QNetworkInterface_allInterfaces() | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return (QNetworkInterface::allInterfaces()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QNetworkInterface::InterfaceFlags PythonQtWrapper_QNetworkInterface::flags(QNetworkInterface* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->flags()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r120 | QString PythonQtWrapper_QNetworkInterface::hardwareAddress(QNetworkInterface* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r120 | return ( theWrappedObject->hardwareAddress()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QString PythonQtWrapper_QNetworkInterface::humanReadableName(QNetworkInterface* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->humanReadableName()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r110 | int PythonQtWrapper_QNetworkInterface::index(QNetworkInterface* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r110 | return ( theWrappedObject->index()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QNetworkInterface PythonQtWrapper_QNetworkInterface::static_QNetworkInterface_interfaceFromIndex(int index) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return (QNetworkInterface::interfaceFromIndex(index)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r110 | QNetworkInterface PythonQtWrapper_QNetworkInterface::static_QNetworkInterface_interfaceFromName(const QString& name) | ||
florianlink
|
r99 | { | ||
florianlink
|
r110 | return (QNetworkInterface::interfaceFromName(name)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QNetworkInterface::isValid(QNetworkInterface* theWrappedObject) const | ||
{ | ||||
return ( theWrappedObject->isValid()); | ||||
} | ||||
florianlink
|
r120 | QString PythonQtWrapper_QNetworkInterface::name(QNetworkInterface* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r120 | return ( theWrappedObject->name()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r117 | QString PythonQtWrapper_QNetworkInterface::py_toString(QNetworkInterface* obj) { | ||
florianlink
|
r110 | QString result; | ||
QDebug d(&result); | ||||
d << *obj; | ||||
return result; | ||||
florianlink
|
r99 | } | ||
florianlink
|
r110 | QNetworkProxy* PythonQtWrapper_QNetworkProxy::new_QNetworkProxy() | ||
florianlink
|
r99 | { | ||
florianlink
|
r110 | return new QNetworkProxy(); } | ||
florianlink
|
r99 | |||
florianlink
|
r110 | QNetworkProxy* PythonQtWrapper_QNetworkProxy::new_QNetworkProxy(QNetworkProxy::ProxyType type, const QString& hostName, unsigned short port, const QString& user, const QString& password) | ||
florianlink
|
r99 | { | ||
florianlink
|
r110 | return new QNetworkProxy(type, hostName, port, user, password); } | ||
florianlink
|
r99 | |||
florianlink
|
r110 | QNetworkProxy* PythonQtWrapper_QNetworkProxy::new_QNetworkProxy(const QNetworkProxy& other) | ||
{ | ||||
return new QNetworkProxy(other); } | ||||
QNetworkProxy PythonQtWrapper_QNetworkProxy::static_QNetworkProxy_applicationProxy() | ||||
florianlink
|
r99 | { | ||
florianlink
|
r110 | return (QNetworkProxy::applicationProxy()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QNetworkProxy::Capabilities PythonQtWrapper_QNetworkProxy::capabilities(QNetworkProxy* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->capabilities()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QString PythonQtWrapper_QNetworkProxy::hostName(QNetworkProxy* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->hostName()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QNetworkProxy::isCachingProxy(QNetworkProxy* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->isCachingProxy()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QNetworkProxy::isTransparentProxy(QNetworkProxy* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->isTransparentProxy()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QNetworkProxy::__ne__(QNetworkProxy* theWrappedObject, const QNetworkProxy& other) const | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | return ( (*theWrappedObject)!= other); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QNetworkProxy::__eq__(QNetworkProxy* theWrappedObject, const QNetworkProxy& other) const | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | return ( (*theWrappedObject)== other); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | QString PythonQtWrapper_QNetworkProxy::password(QNetworkProxy* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->password()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | unsigned short PythonQtWrapper_QNetworkProxy::port(QNetworkProxy* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->port()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QNetworkProxy::static_QNetworkProxy_setApplicationProxy(const QNetworkProxy& proxy) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | (QNetworkProxy::setApplicationProxy(proxy)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QNetworkProxy::setCapabilities(QNetworkProxy* theWrappedObject, QNetworkProxy::Capabilities capab) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( theWrappedObject->setCapabilities(capab)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QNetworkProxy::setHostName(QNetworkProxy* theWrappedObject, const QString& hostName) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( theWrappedObject->setHostName(hostName)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QNetworkProxy::setPassword(QNetworkProxy* theWrappedObject, const QString& password) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( theWrappedObject->setPassword(password)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r110 | |||
florianlink
|
r128 | void PythonQtWrapper_QNetworkProxy::setPort(QNetworkProxy* theWrappedObject, unsigned short port) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( theWrappedObject->setPort(port)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r110 | |||
florianlink
|
r128 | void PythonQtWrapper_QNetworkProxy::setType(QNetworkProxy* theWrappedObject, QNetworkProxy::ProxyType type) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( theWrappedObject->setType(type)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r120 | void PythonQtWrapper_QNetworkProxy::setUser(QNetworkProxy* theWrappedObject, const QString& userName) | ||
florianlink
|
r99 | { | ||
florianlink
|
r120 | ( theWrappedObject->setUser(userName)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r110 | |||
florianlink
|
r120 | QNetworkProxy::ProxyType PythonQtWrapper_QNetworkProxy::type(QNetworkProxy* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r120 | return ( theWrappedObject->type()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r110 | |||
florianlink
|
r128 | QString PythonQtWrapper_QNetworkProxy::user(QNetworkProxy* theWrappedObject) const | ||
{ | ||||
return ( theWrappedObject->user()); | ||||
} | ||||
florianlink
|
r110 | |||
florianlink
|
r186 | PythonQtShell_QNetworkProxyFactory::~PythonQtShell_QNetworkProxyFactory() { | ||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
florianlink
|
r110 | QList<QNetworkProxy > PythonQtShell_QNetworkProxyFactory::queryProxy(const QNetworkProxyQuery& query) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r110 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "queryProxy"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r110 | static const char* argumentList[] ={"QList<QNetworkProxy >" , "const QNetworkProxyQuery&"}; | ||
florianlink
|
r99 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r110 | QList<QNetworkProxy > returnValue; | ||
void* args[2] = {NULL, (void*)&query}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r110 | PythonQt::priv()->handleVirtualOverloadReturnError("queryProxy", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r110 | returnValue = *((QList<QNetworkProxy >*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r120 | return QList<QNetworkProxy >(); | ||
florianlink
|
r110 | } | ||
QNetworkProxyFactory* PythonQtWrapper_QNetworkProxyFactory::new_QNetworkProxyFactory() | ||||
{ | ||||
return new PythonQtShell_QNetworkProxyFactory(); } | ||||
florianlink
|
r128 | QList<QNetworkProxy > PythonQtWrapper_QNetworkProxyFactory::static_QNetworkProxyFactory_proxyForQuery(const QNetworkProxyQuery& query) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return (QNetworkProxyFactory::proxyForQuery(query)); | ||
florianlink
|
r110 | } | ||
void PythonQtWrapper_QNetworkProxyFactory::static_QNetworkProxyFactory_setApplicationProxyFactory(QNetworkProxyFactory* factory) | ||||
{ | ||||
(QNetworkProxyFactory::setApplicationProxyFactory(factory)); | ||||
} | ||||
florianlink
|
r128 | void PythonQtWrapper_QNetworkProxyFactory::static_QNetworkProxyFactory_setUseSystemConfiguration(bool enable) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | (QNetworkProxyFactory::setUseSystemConfiguration(enable)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | QList<QNetworkProxy > PythonQtWrapper_QNetworkProxyFactory::static_QNetworkProxyFactory_systemProxyForQuery(const QNetworkProxyQuery& query) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return (QNetworkProxyFactory::systemProxyForQuery(query)); | ||
florianlink
|
r110 | } | ||
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); } | ||||
florianlink
|
r128 | int PythonQtWrapper_QNetworkProxyQuery::localPort(QNetworkProxyQuery* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->localPort()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QNetworkProxyQuery::__ne__(QNetworkProxyQuery* theWrappedObject, const QNetworkProxyQuery& other) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( (*theWrappedObject)!= other); | ||
florianlink
|
r110 | } | ||
florianlink
|
r120 | bool PythonQtWrapper_QNetworkProxyQuery::__eq__(QNetworkProxyQuery* theWrappedObject, const QNetworkProxyQuery& other) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r120 | return ( (*theWrappedObject)== other); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | QString PythonQtWrapper_QNetworkProxyQuery::peerHostName(QNetworkProxyQuery* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->peerHostName()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | int PythonQtWrapper_QNetworkProxyQuery::peerPort(QNetworkProxyQuery* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->peerPort()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | QString PythonQtWrapper_QNetworkProxyQuery::protocolTag(QNetworkProxyQuery* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->protocolTag()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | QNetworkProxyQuery::QueryType PythonQtWrapper_QNetworkProxyQuery::queryType(QNetworkProxyQuery* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->queryType()); | ||
florianlink
|
r110 | } | ||
void PythonQtWrapper_QNetworkProxyQuery::setLocalPort(QNetworkProxyQuery* theWrappedObject, int port) | ||||
{ | ||||
( theWrappedObject->setLocalPort(port)); | ||||
} | ||||
florianlink
|
r128 | void PythonQtWrapper_QNetworkProxyQuery::setPeerHostName(QNetworkProxyQuery* theWrappedObject, const QString& hostname) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | ( theWrappedObject->setPeerHostName(hostname)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QNetworkProxyQuery::setPeerPort(QNetworkProxyQuery* theWrappedObject, int port) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | ( theWrappedObject->setPeerPort(port)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QNetworkProxyQuery::setProtocolTag(QNetworkProxyQuery* theWrappedObject, const QString& protocolTag) | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | ( theWrappedObject->setProtocolTag(protocolTag)); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QNetworkProxyQuery::setQueryType(QNetworkProxyQuery* theWrappedObject, QNetworkProxyQuery::QueryType type) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | ( theWrappedObject->setQueryType(type)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QNetworkProxyQuery::setUrl(QNetworkProxyQuery* theWrappedObject, const QUrl& url) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | ( theWrappedObject->setUrl(url)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | QUrl PythonQtWrapper_QNetworkProxyQuery::url(QNetworkProxyQuery* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->url()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r110 | |||
florianlink
|
r186 | PythonQtShell_QNetworkReply::~PythonQtShell_QNetworkReply() { | ||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
florianlink
|
r128 | void PythonQtShell_QNetworkReply::abort() | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "abort"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={""}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
void* args[1] = {NULL}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r128 | |||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtShell_QNetworkReply::atEnd() const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "atEnd"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r110 | static const char* argumentList[] ={"bool"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
florianlink
|
r99 | bool returnValue; | ||
florianlink
|
r110 | void* args[1] = {NULL}; | ||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("atEnd", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QNetworkReply::atEnd(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | qint64 PythonQtShell_QNetworkReply::bytesAvailable() const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "bytesAvailable"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"qint64"}; | ||
florianlink
|
r110 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||
qint64 returnValue; | ||||
florianlink
|
r128 | void* args[1] = {NULL}; | ||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("bytesAvailable", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r110 | returnValue = *((qint64*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QNetworkReply::bytesAvailable(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | qint64 PythonQtShell_QNetworkReply::bytesToWrite() const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "bytesToWrite"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r117 | static const char* argumentList[] ={"qint64"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
qint64 returnValue; | ||||
void* args[1] = {NULL}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("bytesToWrite", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r117 | returnValue = *((qint64*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QNetworkReply::bytesToWrite(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtShell_QNetworkReply::canReadLine() const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "canReadLine"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r120 | static const char* argumentList[] ={"bool"}; | ||
florianlink
|
r117 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||
florianlink
|
r120 | bool returnValue; | ||
florianlink
|
r117 | void* args[1] = {NULL}; | ||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("canReadLine", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r120 | returnValue = *((bool*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QNetworkReply::canReadLine(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtShell_QNetworkReply::childEvent(QChildEvent* arg__1) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "QChildEvent*"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
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*"}; | ||||
florianlink
|
r120 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
bool returnValue; | ||||
florianlink
|
r128 | void* args[2] = {NULL, (void*)&arg__1}; | ||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r120 | returnValue = *((bool*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QNetworkReply::event(arg__1); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtShell_QNetworkReply::eventFilter(QObject* arg__1, QEvent* arg__2) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
florianlink
|
r117 | bool returnValue; | ||
florianlink
|
r128 | void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2}; | ||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r117 | returnValue = *((bool*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QNetworkReply::eventFilter(arg__1, arg__2); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtShell_QNetworkReply::ignoreSslErrors() | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "ignoreSslErrors"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={""}; | ||
florianlink
|
r117 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||
void* args[1] = {NULL}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
florianlink
|
r128 | return; | ||
florianlink
|
r99 | } | ||
} | ||||
florianlink
|
r128 | QNetworkReply::ignoreSslErrors(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtShell_QNetworkReply::isSequential() const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isSequential"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"bool"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
florianlink
|
r117 | bool returnValue; | ||
florianlink
|
r128 | void* args[1] = {NULL}; | ||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("isSequential", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r117 | returnValue = *((bool*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QNetworkReply::isSequential(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r117 | bool PythonQtShell_QNetworkReply::open(QIODevice::OpenMode mode) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r117 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "open"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r117 | static const char* argumentList[] ={"bool" , "QIODevice::OpenMode"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
florianlink
|
r99 | bool returnValue; | ||
florianlink
|
r117 | void* args[2] = {NULL, (void*)&mode}; | ||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r117 | PythonQt::priv()->handleVirtualOverloadReturnError("open", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r117 | return QNetworkReply::open(mode); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | qint64 PythonQtShell_QNetworkReply::pos() const | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "pos"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"qint64"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
florianlink
|
r120 | qint64 returnValue; | ||
florianlink
|
r128 | void* args[1] = {NULL}; | ||
florianlink
|
r120 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
florianlink
|
r99 | if (args[0]!=&returnValue) { | ||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("pos", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r120 | returnValue = *((qint64*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QNetworkReply::pos(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r120 | qint64 PythonQtShell_QNetworkReply::readData(char* data, qint64 maxlen) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r120 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "readData"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r120 | 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}; | ||||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r120 | PythonQt::priv()->handleVirtualOverloadReturnError("readData", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r120 | returnValue = *((qint64*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r120 | return qint64(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | qint64 PythonQtShell_QNetworkReply::readLineData(char* data, qint64 maxlen) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "readLineData"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"qint64" , "char*" , "qint64"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
florianlink
|
r110 | qint64 returnValue; | ||
florianlink
|
r128 | void* args[3] = {NULL, (void*)&data, (void*)&maxlen}; | ||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("readLineData", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r110 | returnValue = *((qint64*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QNetworkReply::readLineData(data, maxlen); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtShell_QNetworkReply::reset() | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reset"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r117 | static const char* argumentList[] ={"bool"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
florianlink
|
r110 | bool returnValue; | ||
florianlink
|
r117 | void* args[1] = {NULL}; | ||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("reset", methodInfo, result); | ||
florianlink
|
r99 | } else { | ||
florianlink
|
r110 | returnValue = *((bool*)args[0]); | ||
florianlink
|
r99 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QNetworkReply::reset(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtShell_QNetworkReply::seek(qint64 pos) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "seek"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"bool" , "qint64"}; | ||
florianlink
|
r99 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r120 | bool returnValue; | ||
florianlink
|
r128 | void* args[2] = {NULL, (void*)&pos}; | ||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
florianlink
|
r120 | if (result) { | ||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("seek", methodInfo, result); | ||
florianlink
|
r120 | } else { | ||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
florianlink
|
r99 | if (result) { Py_DECREF(result); } | ||
Py_DECREF(obj); | ||||
florianlink
|
r120 | return returnValue; | ||
florianlink
|
r99 | } | ||
} | ||||
florianlink
|
r128 | 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); | ||||
florianlink
|
r110 | } | ||
florianlink
|
r120 | qint64 PythonQtShell_QNetworkReply::size() const | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r120 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "size"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r120 | static const char* argumentList[] ={"qint64"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
qint64 returnValue; | ||||
void* args[1] = {NULL}; | ||||
florianlink
|
r110 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
florianlink
|
r120 | if (result) { | ||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("size", methodInfo, result); | ||||
} else { | ||||
returnValue = *((qint64*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
florianlink
|
r110 | if (result) { Py_DECREF(result); } | ||
Py_DECREF(obj); | ||||
florianlink
|
r120 | return returnValue; | ||
florianlink
|
r110 | } | ||
} | ||||
florianlink
|
r120 | return QNetworkReply::size(); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtShell_QNetworkReply::timerEvent(QTimerEvent* arg__1) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "QTimerEvent*"}; | ||
florianlink
|
r99 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
florianlink
|
r128 | return; | ||
florianlink
|
r99 | } | ||
} | ||||
florianlink
|
r128 | QNetworkReply::timerEvent(arg__1); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | bool PythonQtShell_QNetworkReply::waitForBytesWritten(int msecs) | ||
florianlink
|
r99 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "waitForBytesWritten"); | ||
florianlink
|
r99 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"bool" , "int"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
florianlink
|
r110 | bool returnValue; | ||
florianlink
|
r128 | void* args[2] = {NULL, (void*)&msecs}; | ||
florianlink
|
r99 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
florianlink
|
r110 | if (result) { | ||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("waitForBytesWritten", methodInfo, result); | ||
florianlink
|
r110 | } else { | ||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
florianlink
|
r99 | if (result) { Py_DECREF(result); } | ||
Py_DECREF(obj); | ||||
florianlink
|
r110 | return returnValue; | ||
florianlink
|
r99 | } | ||
} | ||||
florianlink
|
r128 | return QNetworkReply::waitForBytesWritten(msecs); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | bool PythonQtShell_QNetworkReply::waitForReadyRead(int msecs) | ||
florianlink
|
r120 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "waitForReadyRead"); | ||
florianlink
|
r120 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"bool" , "int"}; | ||
florianlink
|
r120 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r128 | bool returnValue; | ||
void* args[2] = {NULL, (void*)&msecs}; | ||||
florianlink
|
r120 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
florianlink
|
r128 | if (result) { | ||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("waitForReadyRead", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
florianlink
|
r120 | if (result) { Py_DECREF(result); } | ||
Py_DECREF(obj); | ||||
florianlink
|
r128 | return returnValue; | ||
florianlink
|
r120 | } | ||
} | ||||
florianlink
|
r128 | return QNetworkReply::waitForReadyRead(msecs); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | qint64 PythonQtShell_QNetworkReply::writeData(const char* data, qint64 len) | ||
florianlink
|
r120 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "writeData"); | ||
florianlink
|
r120 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | 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}; | ||||
florianlink
|
r120 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
florianlink
|
r128 | if (result) { | ||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("writeData", methodInfo, result); | ||||
} else { | ||||
returnValue = *((qint64*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
florianlink
|
r120 | if (result) { Py_DECREF(result); } | ||
Py_DECREF(obj); | ||||
florianlink
|
r128 | return returnValue; | ||
florianlink
|
r120 | } | ||
} | ||||
florianlink
|
r128 | return QNetworkReply::writeData(data, len); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | QVariant PythonQtWrapper_QNetworkReply::attribute(QNetworkReply* theWrappedObject, QNetworkRequest::Attribute code) const | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | return ( theWrappedObject->attribute(code)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QNetworkReply::close(QNetworkReply* theWrappedObject) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | ( ((PythonQtPublicPromoter_QNetworkReply*)theWrappedObject)->promoted_close()); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | QNetworkReply::NetworkError PythonQtWrapper_QNetworkReply::error(QNetworkReply* theWrappedObject) const | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | return ( theWrappedObject->error()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QNetworkReply::hasRawHeader(QNetworkReply* theWrappedObject, const QByteArray& headerName) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->hasRawHeader(headerName)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | QVariant PythonQtWrapper_QNetworkReply::header(QNetworkReply* theWrappedObject, QNetworkRequest::KnownHeaders header) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->header(header)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r186 | void PythonQtWrapper_QNetworkReply::ignoreSslErrors(QNetworkReply* theWrappedObject) | ||
{ | ||||
( ((PythonQtPublicPromoter_QNetworkReply*)theWrappedObject)->promoted_ignoreSslErrors()); | ||||
} | ||||
florianlink
|
r128 | bool PythonQtWrapper_QNetworkReply::isFinished(QNetworkReply* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->isFinished()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QNetworkReply::isRunning(QNetworkReply* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->isRunning()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QNetworkReply::isSequential(QNetworkReply* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QNetworkReply*)theWrappedObject)->promoted_isSequential()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | QNetworkAccessManager* PythonQtWrapper_QNetworkReply::manager(QNetworkReply* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->manager()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | QNetworkAccessManager::Operation PythonQtWrapper_QNetworkReply::operation(QNetworkReply* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->operation()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | QByteArray PythonQtWrapper_QNetworkReply::rawHeader(QNetworkReply* theWrappedObject, const QByteArray& headerName) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->rawHeader(headerName)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | QList<QByteArray > PythonQtWrapper_QNetworkReply::rawHeaderList(QNetworkReply* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->rawHeaderList()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r186 | const QList<QPair<QByteArray , QByteArray > >* PythonQtWrapper_QNetworkReply::rawHeaderPairs(QNetworkReply* theWrappedObject) const | ||
{ | ||||
return &( theWrappedObject->rawHeaderPairs()); | ||||
} | ||||
florianlink
|
r128 | qint64 PythonQtWrapper_QNetworkReply::readBufferSize(QNetworkReply* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->readBufferSize()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | QNetworkRequest PythonQtWrapper_QNetworkReply::request(QNetworkReply* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->request()); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QNetworkReply::setReadBufferSize(QNetworkReply* theWrappedObject, qint64 size) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | ( ((PythonQtPublicPromoter_QNetworkReply*)theWrappedObject)->promoted_setReadBufferSize(size)); | ||
florianlink
|
r110 | } | ||
QUrl PythonQtWrapper_QNetworkReply::url(QNetworkReply* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->url()); | ||||
} | ||||
florianlink
|
r128 | qint64 PythonQtWrapper_QNetworkReply::writeData(QNetworkReply* theWrappedObject, const char* data, qint64 len) | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QNetworkReply*)theWrappedObject)->promoted_writeData(data, len)); | ||
florianlink
|
r110 | } | ||
QNetworkRequest* PythonQtWrapper_QNetworkRequest::new_QNetworkRequest(const QNetworkRequest& other) | ||||
{ | ||||
return new QNetworkRequest(other); } | ||||
QNetworkRequest* PythonQtWrapper_QNetworkRequest::new_QNetworkRequest(const QUrl& url) | ||||
{ | ||||
return new QNetworkRequest(url); } | ||||
florianlink
|
r128 | QVariant PythonQtWrapper_QNetworkRequest::attribute(QNetworkRequest* theWrappedObject, QNetworkRequest::Attribute code, const QVariant& defaultValue) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->attribute(code, defaultValue)); | ||
florianlink
|
r110 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QNetworkRequest::hasRawHeader(QNetworkRequest* theWrappedObject, const QByteArray& headerName) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->hasRawHeader(headerName)); | ||
florianlink
|
r110 | } | ||
QVariant PythonQtWrapper_QNetworkRequest::header(QNetworkRequest* theWrappedObject, QNetworkRequest::KnownHeaders header) const | ||||
{ | ||||
return ( theWrappedObject->header(header)); | ||||
} | ||||
florianlink
|
r128 | bool PythonQtWrapper_QNetworkRequest::__ne__(QNetworkRequest* theWrappedObject, const QNetworkRequest& other) const | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | return ( (*theWrappedObject)!= other); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QNetworkRequest::__eq__(QNetworkRequest* theWrappedObject, const QNetworkRequest& other) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( (*theWrappedObject)== other); | ||
florianlink
|
r99 | } | ||
florianlink
|
r110 | |||
florianlink
|
r128 | QObject* PythonQtWrapper_QNetworkRequest::originatingObject(QNetworkRequest* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->originatingObject()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r110 | |||
florianlink
|
r186 | QNetworkRequest::Priority PythonQtWrapper_QNetworkRequest::priority(QNetworkRequest* theWrappedObject) const | ||
{ | ||||
return ( theWrappedObject->priority()); | ||||
} | ||||
florianlink
|
r128 | QByteArray PythonQtWrapper_QNetworkRequest::rawHeader(QNetworkRequest* theWrappedObject, const QByteArray& headerName) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r128 | return ( theWrappedObject->rawHeader(headerName)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | QList<QByteArray > PythonQtWrapper_QNetworkRequest::rawHeaderList(QNetworkRequest* theWrappedObject) const | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | return ( theWrappedObject->rawHeaderList()); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QNetworkRequest::setAttribute(QNetworkRequest* theWrappedObject, QNetworkRequest::Attribute code, const QVariant& value) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( theWrappedObject->setAttribute(code, value)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QNetworkRequest::setHeader(QNetworkRequest* theWrappedObject, QNetworkRequest::KnownHeaders header, const QVariant& value) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( theWrappedObject->setHeader(header, value)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QNetworkRequest::setOriginatingObject(QNetworkRequest* theWrappedObject, QObject* object) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( theWrappedObject->setOriginatingObject(object)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r186 | void PythonQtWrapper_QNetworkRequest::setPriority(QNetworkRequest* theWrappedObject, QNetworkRequest::Priority priority) | ||
{ | ||||
( theWrappedObject->setPriority(priority)); | ||||
} | ||||
florianlink
|
r128 | void PythonQtWrapper_QNetworkRequest::setRawHeader(QNetworkRequest* theWrappedObject, const QByteArray& headerName, const QByteArray& value) | ||
florianlink
|
r99 | { | ||
florianlink
|
r128 | ( theWrappedObject->setRawHeader(headerName, value)); | ||
florianlink
|
r99 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QNetworkRequest::setUrl(QNetworkRequest* theWrappedObject, const QUrl& url) | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | ( theWrappedObject->setUrl(url)); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | QUrl PythonQtWrapper_QNetworkRequest::url(QNetworkRequest* theWrappedObject) const | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | return ( theWrappedObject->url()); | ||
florianlink
|
r120 | } | ||
florianlink
|
r186 | PythonQtShell_QTcpServer::~PythonQtShell_QTcpServer() { | ||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
florianlink
|
r128 | void PythonQtShell_QTcpServer::childEvent(QChildEvent* arg__1) | ||
florianlink
|
r120 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent"); | ||
florianlink
|
r120 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "QChildEvent*"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
florianlink
|
r120 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
florianlink
|
r128 | return; | ||
florianlink
|
r120 | } | ||
} | ||||
florianlink
|
r128 | QTcpServer::childEvent(arg__1); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | void PythonQtShell_QTcpServer::customEvent(QEvent* arg__1) | ||
florianlink
|
r120 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent"); | ||
florianlink
|
r120 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "QEvent*"}; | ||
florianlink
|
r120 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r128 | void* args[2] = {NULL, (void*)&arg__1}; | ||
florianlink
|
r120 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r128 | QTcpServer::customEvent(arg__1); | ||
florianlink
|
r120 | } | ||
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); | ||||
} | ||||
florianlink
|
r128 | bool PythonQtShell_QTcpServer::hasPendingConnections() const | ||
florianlink
|
r120 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasPendingConnections"); | ||
florianlink
|
r120 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | 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(); | ||||
} | ||||
void PythonQtShell_QTcpServer::incomingConnection(int handle) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "incomingConnection"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "int"}; | ||||
florianlink
|
r120 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
florianlink
|
r128 | void* args[2] = {NULL, (void*)&handle}; | ||
florianlink
|
r120 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r128 | QTcpServer::incomingConnection(handle); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | QTcpSocket* PythonQtShell_QTcpServer::nextPendingConnection() | ||
florianlink
|
r120 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nextPendingConnection"); | ||
florianlink
|
r120 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"QTcpSocket*"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QTcpSocket* returnValue; | ||||
void* args[1] = {NULL}; | ||||
florianlink
|
r120 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
florianlink
|
r128 | if (result) { | ||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("nextPendingConnection", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QTcpSocket**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
florianlink
|
r120 | if (result) { Py_DECREF(result); } | ||
Py_DECREF(obj); | ||||
florianlink
|
r128 | return returnValue; | ||
florianlink
|
r120 | } | ||
} | ||||
florianlink
|
r128 | return QTcpServer::nextPendingConnection(); | ||
florianlink
|
r120 | } | ||
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); } | ||||
florianlink
|
r128 | void PythonQtWrapper_QTcpServer::close(QTcpServer* theWrappedObject) | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | ( theWrappedObject->close()); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | QString PythonQtWrapper_QTcpServer::errorString(QTcpServer* theWrappedObject) const | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | return ( theWrappedObject->errorString()); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QTcpServer::hasPendingConnections(QTcpServer* theWrappedObject) const | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QTcpServer*)theWrappedObject)->promoted_hasPendingConnections()); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | void PythonQtWrapper_QTcpServer::incomingConnection(QTcpServer* theWrappedObject, int handle) | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | ( ((PythonQtPublicPromoter_QTcpServer*)theWrappedObject)->promoted_incomingConnection(handle)); | ||
florianlink
|
r120 | } | ||
bool PythonQtWrapper_QTcpServer::isListening(QTcpServer* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isListening()); | ||||
} | ||||
florianlink
|
r128 | bool PythonQtWrapper_QTcpServer::listen(QTcpServer* theWrappedObject, const QHostAddress& address, unsigned short port) | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | return ( theWrappedObject->listen(address, port)); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | int PythonQtWrapper_QTcpServer::maxPendingConnections(QTcpServer* theWrappedObject) const | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | return ( theWrappedObject->maxPendingConnections()); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | QTcpSocket* PythonQtWrapper_QTcpServer::nextPendingConnection(QTcpServer* theWrappedObject) | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | return ( ((PythonQtPublicPromoter_QTcpServer*)theWrappedObject)->promoted_nextPendingConnection()); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | QNetworkProxy PythonQtWrapper_QTcpServer::proxy(QTcpServer* theWrappedObject) const | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | return ( theWrappedObject->proxy()); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | QHostAddress PythonQtWrapper_QTcpServer::serverAddress(QTcpServer* theWrappedObject) const | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | return ( theWrappedObject->serverAddress()); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | QAbstractSocket::SocketError PythonQtWrapper_QTcpServer::serverError(QTcpServer* theWrappedObject) const | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | return ( theWrappedObject->serverError()); | ||
} | ||||
unsigned short PythonQtWrapper_QTcpServer::serverPort(QTcpServer* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->serverPort()); | ||||
florianlink
|
r120 | } | ||
void PythonQtWrapper_QTcpServer::setMaxPendingConnections(QTcpServer* theWrappedObject, int numConnections) | ||||
{ | ||||
( theWrappedObject->setMaxPendingConnections(numConnections)); | ||||
} | ||||
florianlink
|
r128 | void PythonQtWrapper_QTcpServer::setProxy(QTcpServer* theWrappedObject, const QNetworkProxy& networkProxy) | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | ( theWrappedObject->setProxy(networkProxy)); | ||
florianlink
|
r120 | } | ||
bool PythonQtWrapper_QTcpServer::setSocketDescriptor(QTcpServer* theWrappedObject, int socketDescriptor) | ||||
{ | ||||
return ( theWrappedObject->setSocketDescriptor(socketDescriptor)); | ||||
} | ||||
florianlink
|
r128 | int PythonQtWrapper_QTcpServer::socketDescriptor(QTcpServer* theWrappedObject) const | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | return ( theWrappedObject->socketDescriptor()); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | bool PythonQtWrapper_QTcpServer::waitForNewConnection(QTcpServer* theWrappedObject, int msec, bool* timedOut) | ||
florianlink
|
r120 | { | ||
florianlink
|
r128 | return ( theWrappedObject->waitForNewConnection(msec, timedOut)); | ||
florianlink
|
r120 | } | ||
florianlink
|
r186 | PythonQtShell_QTcpSocket::~PythonQtShell_QTcpSocket() { | ||
PythonQtPrivate* priv = PythonQt::priv(); | ||||
if (priv) { priv->shellClassDeleted(this); } | ||||
} | ||||
florianlink
|
r128 | bool PythonQtShell_QTcpSocket::atEnd() const | ||
florianlink
|
r120 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "atEnd"); | ||
florianlink
|
r120 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"bool"}; | ||
florianlink
|
r120 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||
florianlink
|
r128 | bool returnValue; | ||
florianlink
|
r120 | void* args[1] = {NULL}; | ||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
florianlink
|
r128 | if (result) { | ||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("atEnd", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
florianlink
|
r120 | if (result) { Py_DECREF(result); } | ||
Py_DECREF(obj); | ||||
florianlink
|
r128 | return returnValue; | ||
florianlink
|
r120 | } | ||
} | ||||
florianlink
|
r128 | return QTcpSocket::atEnd(); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | qint64 PythonQtShell_QTcpSocket::bytesAvailable() const | ||
florianlink
|
r120 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "bytesAvailable"); | ||
florianlink
|
r120 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"qint64"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
florianlink
|
r120 | qint64 returnValue; | ||
florianlink
|
r128 | void* args[1] = {NULL}; | ||
florianlink
|
r120 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("bytesAvailable", methodInfo, result); | ||
florianlink
|
r120 | } else { | ||
returnValue = *((qint64*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | 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(); | ||||
florianlink
|
r120 | } | ||
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(); | ||||
} | ||||
florianlink
|
r128 | void PythonQtShell_QTcpSocket::childEvent(QChildEvent* arg__1) | ||
florianlink
|
r120 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent"); | ||
florianlink
|
r120 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"" , "QChildEvent*"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
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::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); | ||||
} | ||||
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}; | ||||
florianlink
|
r120 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result); | ||
florianlink
|
r120 | } else { | ||
florianlink
|
r128 | returnValue = *((bool*)args[0]); | ||
florianlink
|
r120 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QTcpSocket::event(arg__1); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | bool PythonQtShell_QTcpSocket::eventFilter(QObject* arg__1, QEvent* arg__2) | ||
florianlink
|
r120 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter"); | ||
florianlink
|
r120 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
florianlink
|
r120 | bool returnValue; | ||
florianlink
|
r128 | void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2}; | ||
florianlink
|
r120 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result); | ||
florianlink
|
r120 | } else { | ||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QTcpSocket::eventFilter(arg__1, arg__2); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | bool PythonQtShell_QTcpSocket::isSequential() const | ||
florianlink
|
r120 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isSequential"); | ||
florianlink
|
r120 | 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) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("isSequential", methodInfo, result); | ||
florianlink
|
r120 | } else { | ||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QTcpSocket::isSequential(); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | bool PythonQtShell_QTcpSocket::open(QIODevice::OpenMode mode) | ||
florianlink
|
r120 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "open"); | ||
florianlink
|
r120 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"bool" , "QIODevice::OpenMode"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
florianlink
|
r120 | bool returnValue; | ||
florianlink
|
r128 | void* args[2] = {NULL, (void*)&mode}; | ||
florianlink
|
r120 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("open", methodInfo, result); | ||
florianlink
|
r120 | } else { | ||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QTcpSocket::open(mode); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | qint64 PythonQtShell_QTcpSocket::pos() const | ||
florianlink
|
r120 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "pos"); | ||
florianlink
|
r120 | 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) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("pos", methodInfo, result); | ||
florianlink
|
r120 | } else { | ||
returnValue = *((qint64*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QTcpSocket::pos(); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | qint64 PythonQtShell_QTcpSocket::readData(char* data, qint64 maxlen) | ||
florianlink
|
r120 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "readData"); | ||
florianlink
|
r120 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"qint64" , "char*" , "qint64"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
florianlink
|
r120 | qint64 returnValue; | ||
florianlink
|
r128 | void* args[3] = {NULL, (void*)&data, (void*)&maxlen}; | ||
florianlink
|
r120 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("readData", methodInfo, result); | ||
florianlink
|
r120 | } else { | ||
returnValue = *((qint64*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QTcpSocket::readData(data, maxlen); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | qint64 PythonQtShell_QTcpSocket::readLineData(char* data, qint64 maxlen) | ||
florianlink
|
r120 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "readLineData"); | ||
florianlink
|
r120 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"qint64" , "char*" , "qint64"}; | ||
florianlink
|
r120 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||
qint64 returnValue; | ||||
florianlink
|
r128 | void* args[3] = {NULL, (void*)&data, (void*)&maxlen}; | ||
florianlink
|
r120 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("readLineData", methodInfo, result); | ||
florianlink
|
r120 | } else { | ||
returnValue = *((qint64*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QTcpSocket::readLineData(data, maxlen); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | bool PythonQtShell_QTcpSocket::reset() | ||
florianlink
|
r120 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reset"); | ||
florianlink
|
r120 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"bool"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
florianlink
|
r120 | bool returnValue; | ||
florianlink
|
r128 | void* args[1] = {NULL}; | ||
florianlink
|
r120 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("reset", methodInfo, result); | ||
florianlink
|
r120 | } else { | ||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QTcpSocket::reset(); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | bool PythonQtShell_QTcpSocket::seek(qint64 pos) | ||
florianlink
|
r120 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "seek"); | ||
florianlink
|
r120 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"bool" , "qint64"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
florianlink
|
r120 | bool returnValue; | ||
florianlink
|
r128 | void* args[2] = {NULL, (void*)&pos}; | ||
florianlink
|
r120 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("seek", methodInfo, result); | ||
florianlink
|
r120 | } else { | ||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QTcpSocket::seek(pos); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | qint64 PythonQtShell_QTcpSocket::size() const | ||
florianlink
|
r120 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "size"); | ||
florianlink
|
r120 | 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) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("size", methodInfo, result); | ||
florianlink
|
r120 | } else { | ||
returnValue = *((qint64*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QTcpSocket::size(); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | void PythonQtShell_QTcpSocket::timerEvent(QTimerEvent* arg__1) | ||
florianlink
|
r120 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent"); | ||
florianlink
|
r120 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | 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"}; | ||||
florianlink
|
r120 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
bool returnValue; | ||||
florianlink
|
r128 | void* args[2] = {NULL, (void*)&msecs}; | ||
florianlink
|
r120 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("waitForBytesWritten", methodInfo, result); | ||
florianlink
|
r120 | } else { | ||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QTcpSocket::waitForBytesWritten(msecs); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | bool PythonQtShell_QTcpSocket::waitForReadyRead(int msecs) | ||
florianlink
|
r120 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "waitForReadyRead"); | ||
florianlink
|
r120 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"bool" , "int"}; | ||
florianlink
|
r120 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
bool returnValue; | ||||
florianlink
|
r128 | void* args[2] = {NULL, (void*)&msecs}; | ||
florianlink
|
r120 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("waitForReadyRead", methodInfo, result); | ||
florianlink
|
r120 | } else { | ||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QTcpSocket::waitForReadyRead(msecs); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | qint64 PythonQtShell_QTcpSocket::writeData(const char* data, qint64 len) | ||
florianlink
|
r120 | { | ||
if (_wrapper) { | ||||
florianlink
|
r128 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "writeData"); | ||
florianlink
|
r120 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r128 | static const char* argumentList[] ={"qint64" , "const char*" , "qint64"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
florianlink
|
r120 | qint64 returnValue; | ||
florianlink
|
r128 | void* args[3] = {NULL, (void*)&data, (void*)&len}; | ||
florianlink
|
r120 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
florianlink
|
r128 | PythonQt::priv()->handleVirtualOverloadReturnError("writeData", methodInfo, result); | ||
florianlink
|
r120 | } else { | ||
returnValue = *((qint64*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r128 | return QTcpSocket::writeData(data, len); | ||
florianlink
|
r120 | } | ||
florianlink
|
r128 | QTcpSocket* PythonQtWrapper_QTcpSocket::new_QTcpSocket(QObject* parent) | ||
{ | ||||
return new PythonQtShell_QTcpSocket(parent); } | ||||