com_trolltech_qt_network1.cpp
2721 lines
| 96.1 KiB
| text/x-c
|
CppLexer
florianlink
|
r110 | #include "com_trolltech_qt_network1.h" | ||
#include <PythonQtConversion.h> | ||||
#include <PythonQtMethodInfo.h> | ||||
#include <PythonQtSignalReceiver.h> | ||||
#include <QVariant> | ||||
#include <qauthenticator.h> | ||||
#include <qbytearray.h> | ||||
#include <qcoreevent.h> | ||||
#include <qdatetime.h> | ||||
#include <qhostaddress.h> | ||||
#include <qiodevice.h> | ||||
#include <qlist.h> | ||||
#include <qnetworkproxy.h> | ||||
#include <qobject.h> | ||||
#include <qsslcertificate.h> | ||||
#include <qsslcipher.h> | ||||
#include <qsslconfiguration.h> | ||||
#include <qsslerror.h> | ||||
#include <qsslkey.h> | ||||
#include <qsslsocket.h> | ||||
#include <qtcpserver.h> | ||||
#include <qtcpsocket.h> | ||||
#include <qudpsocket.h> | ||||
#include <qurl.h> | ||||
#include <qurlinfo.h> | ||||
QSslKey* PythonQtWrapper_QSslKey::new_QSslKey() | ||||
{ | ||||
return new QSslKey(); } | ||||
QSslKey* PythonQtWrapper_QSslKey::new_QSslKey(QIODevice* device, QSsl::KeyAlgorithm algorithm, QSsl::EncodingFormat format, QSsl::KeyType type, const QByteArray& passPhrase) | ||||
{ | ||||
return new QSslKey(device, algorithm, format, type, passPhrase); } | ||||
QSslKey* PythonQtWrapper_QSslKey::new_QSslKey(const QByteArray& encoded, QSsl::KeyAlgorithm algorithm, QSsl::EncodingFormat format, QSsl::KeyType type, const QByteArray& passPhrase) | ||||
{ | ||||
return new QSslKey(encoded, algorithm, format, type, passPhrase); } | ||||
QSslKey* PythonQtWrapper_QSslKey::new_QSslKey(const QSslKey& other) | ||||
{ | ||||
return new QSslKey(other); } | ||||
QSsl::KeyAlgorithm PythonQtWrapper_QSslKey::algorithm(QSslKey* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->algorithm()); | ||||
} | ||||
QByteArray PythonQtWrapper_QSslKey::toDer(QSslKey* theWrappedObject, const QByteArray& passPhrase) const | ||||
{ | ||||
return ( theWrappedObject->toDer(passPhrase)); | ||||
} | ||||
QSslKey* PythonQtWrapper_QSslKey::operator_assign(QSslKey* theWrappedObject, const QSslKey& other) | ||||
{ | ||||
return &( (*theWrappedObject)= other); | ||||
} | ||||
void PythonQtWrapper_QSslKey::clear(QSslKey* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->clear()); | ||||
} | ||||
int PythonQtWrapper_QSslKey::length(QSslKey* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->length()); | ||||
} | ||||
QByteArray PythonQtWrapper_QSslKey::toPem(QSslKey* theWrappedObject, const QByteArray& passPhrase) const | ||||
{ | ||||
return ( theWrappedObject->toPem(passPhrase)); | ||||
} | ||||
Qt::HANDLE PythonQtWrapper_QSslKey::handle(QSslKey* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->handle()); | ||||
} | ||||
QSsl::KeyType PythonQtWrapper_QSslKey::type(QSslKey* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->type()); | ||||
} | ||||
bool PythonQtWrapper_QSslKey::operator_equal(QSslKey* theWrappedObject, const QSslKey& key) const | ||||
{ | ||||
return ( (*theWrappedObject)== key); | ||||
} | ||||
bool PythonQtWrapper_QSslKey::isNull(QSslKey* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isNull()); | ||||
} | ||||
florianlink
|
r117 | QString PythonQtWrapper_QSslKey::py_toString(QSslKey* obj) { | ||
florianlink
|
r110 | QString result; | ||
QDebug d(&result); | ||||
d << *obj; | ||||
return result; | ||||
} | ||||
bool PythonQtShell_QSslSocket::canReadLine() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "canReadLine"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
bool returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("canReadLine", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QSslSocket::canReadLine(); | ||||
} | ||||
qint64 PythonQtShell_QSslSocket::bytesToWrite() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "bytesToWrite"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"qint64"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
qint64 returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("bytesToWrite", methodInfo, result); | ||||
} else { | ||||
returnValue = *((qint64*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QSslSocket::bytesToWrite(); | ||||
} | ||||
qint64 PythonQtShell_QSslSocket::readData(char* data, qint64 maxlen) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "readData"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"qint64" , "char*" , "qint64"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
qint64 returnValue; | ||||
void* args[3] = {NULL, (void*)&data, (void*)&maxlen}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("readData", methodInfo, result); | ||||
} else { | ||||
returnValue = *((qint64*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QSslSocket::readData(data, maxlen); | ||||
} | ||||
qint64 PythonQtShell_QSslSocket::writeData(const char* data, qint64 len) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "writeData"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"qint64" , "const char*" , "qint64"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
qint64 returnValue; | ||||
void* args[3] = {NULL, (void*)&data, (void*)&len}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("writeData", methodInfo, result); | ||||
} else { | ||||
returnValue = *((qint64*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QSslSocket::writeData(data, len); | ||||
} | ||||
qint64 PythonQtShell_QSslSocket::bytesAvailable() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "bytesAvailable"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"qint64"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
qint64 returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("bytesAvailable", methodInfo, result); | ||||
} else { | ||||
returnValue = *((qint64*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QSslSocket::bytesAvailable(); | ||||
} | ||||
bool PythonQtShell_QSslSocket::waitForBytesWritten(int msecs) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "waitForBytesWritten"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&msecs}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("waitForBytesWritten", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QSslSocket::waitForBytesWritten(msecs); | ||||
} | ||||
bool PythonQtShell_QSslSocket::atEnd() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "atEnd"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
bool returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("atEnd", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QSslSocket::atEnd(); | ||||
} | ||||
void PythonQtShell_QSslSocket::close() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "close"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={""}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QSslSocket::close(); | ||||
} | ||||
bool PythonQtShell_QSslSocket::waitForReadyRead(int msecs) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "waitForReadyRead"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&msecs}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("waitForReadyRead", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QSslSocket::waitForReadyRead(msecs); | ||||
} | ||||
florianlink
|
r117 | qint64 PythonQtShell_QSslSocket::readLineData(char* data, qint64 maxlen) | ||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "readLineData"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"qint64" , "char*" , "qint64"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
qint64 returnValue; | ||||
void* args[3] = {NULL, (void*)&data, (void*)&maxlen}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("readLineData", methodInfo, result); | ||||
} else { | ||||
returnValue = *((qint64*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QSslSocket::readLineData(data, maxlen); | ||||
} | ||||
florianlink
|
r110 | bool PythonQtShell_QSslSocket::isSequential() const | ||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isSequential"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
bool returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("isSequential", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QSslSocket::isSequential(); | ||||
} | ||||
florianlink
|
r117 | qint64 PythonQtShell_QSslSocket::size() const | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r117 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "size"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r117 | static const char* argumentList[] ={"qint64"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
florianlink
|
r110 | qint64 returnValue; | ||
florianlink
|
r117 | 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
|
r117 | PythonQt::priv()->handleVirtualOverloadReturnError("size", methodInfo, result); | ||
florianlink
|
r110 | } else { | ||
returnValue = *((qint64*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r117 | return QSslSocket::size(); | ||
} | ||||
qint64 PythonQtShell_QSslSocket::pos() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "pos"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"qint64"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
qint64 returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("pos", methodInfo, result); | ||||
} else { | ||||
returnValue = *((qint64*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QSslSocket::pos(); | ||||
florianlink
|
r110 | } | ||
bool PythonQtShell_QSslSocket::reset() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reset"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
bool returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("reset", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QSslSocket::reset(); | ||||
} | ||||
bool PythonQtShell_QSslSocket::open(QIODevice::OpenMode mode) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "open"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "QIODevice::OpenMode"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&mode}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("open", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QSslSocket::open(mode); | ||||
} | ||||
bool PythonQtShell_QSslSocket::seek(qint64 pos) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "seek"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "qint64"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&pos}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("seek", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QSslSocket::seek(pos); | ||||
} | ||||
florianlink
|
r117 | void PythonQtShell_QSslSocket::childEvent(QChildEvent* arg__1) | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r117 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r117 | static const char* argumentList[] ={"" , "QChildEvent*"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
florianlink
|
r110 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
florianlink
|
r117 | return; | ||
florianlink
|
r110 | } | ||
} | ||||
florianlink
|
r117 | QSslSocket::childEvent(arg__1); | ||
florianlink
|
r110 | } | ||
void PythonQtShell_QSslSocket::timerEvent(QTimerEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QTimerEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QSslSocket::timerEvent(arg__1); | ||||
} | ||||
florianlink
|
r117 | void PythonQtShell_QSslSocket::customEvent(QEvent* arg__1) | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r117 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r117 | static const char* argumentList[] ={"" , "QEvent*"}; | ||
florianlink
|
r110 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r117 | QSslSocket::customEvent(arg__1); | ||
florianlink
|
r110 | } | ||
bool PythonQtShell_QSslSocket::event(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "QEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QSslSocket::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QSslSocket::eventFilter(QObject* arg__1, QEvent* arg__2) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
bool returnValue; | ||||
void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QSslSocket::eventFilter(arg__1, arg__2); | ||||
} | ||||
QSslSocket* PythonQtWrapper_QSslSocket::new_QSslSocket(QObject* parent) | ||||
{ | ||||
return new PythonQtShell_QSslSocket(parent); } | ||||
QSslSocket::SslMode PythonQtWrapper_QSslSocket::mode(QSslSocket* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->mode()); | ||||
} | ||||
void PythonQtWrapper_QSslSocket::setProtocol(QSslSocket* theWrappedObject, QSsl::SslProtocol protocol) | ||||
{ | ||||
( theWrappedObject->setProtocol(protocol)); | ||||
} | ||||
void PythonQtWrapper_QSslSocket::static_QSslSocket_setDefaultCiphers(const QList<QSslCipher >& ciphers) | ||||
{ | ||||
(QSslSocket::setDefaultCiphers(ciphers)); | ||||
} | ||||
void PythonQtWrapper_QSslSocket::static_QSslSocket_setDefaultCaCertificates(const QList<QSslCertificate >& certificates) | ||||
{ | ||||
(QSslSocket::setDefaultCaCertificates(certificates)); | ||||
} | ||||
bool PythonQtWrapper_QSslSocket::static_QSslSocket_supportsSsl() | ||||
{ | ||||
return (QSslSocket::supportsSsl()); | ||||
} | ||||
void PythonQtWrapper_QSslSocket::setSocketOption(QSslSocket* theWrappedObject, QAbstractSocket::SocketOption option, const QVariant& value) | ||||
{ | ||||
( theWrappedObject->setSocketOption(option, value)); | ||||
} | ||||
bool PythonQtWrapper_QSslSocket::isEncrypted(QSslSocket* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isEncrypted()); | ||||
} | ||||
bool PythonQtWrapper_QSslSocket::canReadLine(QSslSocket* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_canReadLine()); | ||||
} | ||||
QSslKey PythonQtWrapper_QSslSocket::privateKey(QSslSocket* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->privateKey()); | ||||
} | ||||
QList<QSslCertificate > PythonQtWrapper_QSslSocket::static_QSslSocket_defaultCaCertificates() | ||||
{ | ||||
return (QSslSocket::defaultCaCertificates()); | ||||
} | ||||
QSslConfiguration PythonQtWrapper_QSslSocket::sslConfiguration(QSslSocket* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->sslConfiguration()); | ||||
} | ||||
qint64 PythonQtWrapper_QSslSocket::bytesToWrite(QSslSocket* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_bytesToWrite()); | ||||
} | ||||
void PythonQtWrapper_QSslSocket::setCaCertificates(QSslSocket* theWrappedObject, const QList<QSslCertificate >& certificates) | ||||
{ | ||||
( theWrappedObject->setCaCertificates(certificates)); | ||||
} | ||||
QList<QSslCipher > PythonQtWrapper_QSslSocket::static_QSslSocket_defaultCiphers() | ||||
{ | ||||
return (QSslSocket::defaultCiphers()); | ||||
} | ||||
QList<QSslError > PythonQtWrapper_QSslSocket::sslErrors(QSslSocket* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->sslErrors()); | ||||
} | ||||
void PythonQtWrapper_QSslSocket::connectToHostEncrypted(QSslSocket* theWrappedObject, const QString& hostName, unsigned short port, const QString& sslPeerName, QIODevice::OpenMode mode) | ||||
{ | ||||
( theWrappedObject->connectToHostEncrypted(hostName, port, sslPeerName, mode)); | ||||
} | ||||
void PythonQtWrapper_QSslSocket::connectToHostEncrypted(QSslSocket* theWrappedObject, const QString& hostName, unsigned short port, QIODevice::OpenMode mode) | ||||
{ | ||||
( theWrappedObject->connectToHostEncrypted(hostName, port, mode)); | ||||
} | ||||
void PythonQtWrapper_QSslSocket::ignoreSslErrors(QSslSocket* theWrappedObject, const QList<QSslError >& errors) | ||||
{ | ||||
( theWrappedObject->ignoreSslErrors(errors)); | ||||
} | ||||
void PythonQtWrapper_QSslSocket::setCiphers(QSslSocket* theWrappedObject, const QString& ciphers) | ||||
{ | ||||
( theWrappedObject->setCiphers(ciphers)); | ||||
} | ||||
qint64 PythonQtWrapper_QSslSocket::encryptedBytesAvailable(QSslSocket* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->encryptedBytesAvailable()); | ||||
} | ||||
void PythonQtWrapper_QSslSocket::setCiphers(QSslSocket* theWrappedObject, const QList<QSslCipher >& ciphers) | ||||
{ | ||||
( theWrappedObject->setCiphers(ciphers)); | ||||
} | ||||
void PythonQtWrapper_QSslSocket::addCaCertificates(QSslSocket* theWrappedObject, const QList<QSslCertificate >& certificates) | ||||
{ | ||||
( theWrappedObject->addCaCertificates(certificates)); | ||||
} | ||||
bool PythonQtWrapper_QSslSocket::addCaCertificates(QSslSocket* theWrappedObject, const QString& path, QSsl::EncodingFormat format, QRegExp::PatternSyntax syntax) | ||||
{ | ||||
return ( theWrappedObject->addCaCertificates(path, format, syntax)); | ||||
} | ||||
bool PythonQtWrapper_QSslSocket::flush(QSslSocket* theWrappedObject) | ||||
{ | ||||
return ( theWrappedObject->flush()); | ||||
} | ||||
QSslSocket::PeerVerifyMode PythonQtWrapper_QSslSocket::peerVerifyMode(QSslSocket* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->peerVerifyMode()); | ||||
} | ||||
QSslCertificate PythonQtWrapper_QSslSocket::peerCertificate(QSslSocket* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->peerCertificate()); | ||||
} | ||||
bool PythonQtWrapper_QSslSocket::setSocketDescriptor(QSslSocket* theWrappedObject, int socketDescriptor, QAbstractSocket::SocketState state, QIODevice::OpenMode openMode) | ||||
{ | ||||
return ( theWrappedObject->setSocketDescriptor(socketDescriptor, state, openMode)); | ||||
} | ||||
QList<QSslCertificate > PythonQtWrapper_QSslSocket::caCertificates(QSslSocket* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->caCertificates()); | ||||
} | ||||
void PythonQtWrapper_QSslSocket::setPrivateKey(QSslSocket* theWrappedObject, const QString& fileName, QSsl::KeyAlgorithm algorithm, QSsl::EncodingFormat format, const QByteArray& passPhrase) | ||||
{ | ||||
( theWrappedObject->setPrivateKey(fileName, algorithm, format, passPhrase)); | ||||
} | ||||
qint64 PythonQtWrapper_QSslSocket::readData(QSslSocket* theWrappedObject, char* data, qint64 maxlen) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_readData(data, maxlen)); | ||||
} | ||||
QSslCipher PythonQtWrapper_QSslSocket::sessionCipher(QSslSocket* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->sessionCipher()); | ||||
} | ||||
void PythonQtWrapper_QSslSocket::setPrivateKey(QSslSocket* theWrappedObject, const QSslKey& key) | ||||
{ | ||||
( theWrappedObject->setPrivateKey(key)); | ||||
} | ||||
void PythonQtWrapper_QSslSocket::setReadBufferSize(QSslSocket* theWrappedObject, qint64 size) | ||||
{ | ||||
( theWrappedObject->setReadBufferSize(size)); | ||||
} | ||||
void PythonQtWrapper_QSslSocket::addCaCertificate(QSslSocket* theWrappedObject, const QSslCertificate& certificate) | ||||
{ | ||||
( theWrappedObject->addCaCertificate(certificate)); | ||||
} | ||||
qint64 PythonQtWrapper_QSslSocket::writeData(QSslSocket* theWrappedObject, const char* data, qint64 len) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_writeData(data, len)); | ||||
} | ||||
void PythonQtWrapper_QSslSocket::setSslConfiguration(QSslSocket* theWrappedObject, const QSslConfiguration& config) | ||||
{ | ||||
( theWrappedObject->setSslConfiguration(config)); | ||||
} | ||||
void PythonQtWrapper_QSslSocket::setPeerVerifyDepth(QSslSocket* theWrappedObject, int depth) | ||||
{ | ||||
( theWrappedObject->setPeerVerifyDepth(depth)); | ||||
} | ||||
void PythonQtWrapper_QSslSocket::abort(QSslSocket* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->abort()); | ||||
} | ||||
qint64 PythonQtWrapper_QSslSocket::bytesAvailable(QSslSocket* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_bytesAvailable()); | ||||
} | ||||
bool PythonQtWrapper_QSslSocket::waitForDisconnected(QSslSocket* theWrappedObject, int msecs) | ||||
{ | ||||
return ( theWrappedObject->waitForDisconnected(msecs)); | ||||
} | ||||
bool PythonQtWrapper_QSslSocket::waitForBytesWritten(QSslSocket* theWrappedObject, int msecs) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_waitForBytesWritten(msecs)); | ||||
} | ||||
bool PythonQtWrapper_QSslSocket::atEnd(QSslSocket* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_atEnd()); | ||||
} | ||||
void PythonQtWrapper_QSslSocket::static_QSslSocket_addDefaultCaCertificate(const QSslCertificate& certificate) | ||||
{ | ||||
(QSslSocket::addDefaultCaCertificate(certificate)); | ||||
} | ||||
void PythonQtWrapper_QSslSocket::setPeerVerifyMode(QSslSocket* theWrappedObject, QSslSocket::PeerVerifyMode mode) | ||||
{ | ||||
( theWrappedObject->setPeerVerifyMode(mode)); | ||||
} | ||||
void PythonQtWrapper_QSslSocket::setLocalCertificate(QSslSocket* theWrappedObject, const QString& fileName, QSsl::EncodingFormat format) | ||||
{ | ||||
( theWrappedObject->setLocalCertificate(fileName, format)); | ||||
} | ||||
void PythonQtWrapper_QSslSocket::setLocalCertificate(QSslSocket* theWrappedObject, const QSslCertificate& certificate) | ||||
{ | ||||
( theWrappedObject->setLocalCertificate(certificate)); | ||||
} | ||||
QList<QSslCipher > PythonQtWrapper_QSslSocket::static_QSslSocket_supportedCiphers() | ||||
{ | ||||
return (QSslSocket::supportedCiphers()); | ||||
} | ||||
qint64 PythonQtWrapper_QSslSocket::encryptedBytesToWrite(QSslSocket* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->encryptedBytesToWrite()); | ||||
} | ||||
void PythonQtWrapper_QSslSocket::close(QSslSocket* theWrappedObject) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_close()); | ||||
} | ||||
bool PythonQtWrapper_QSslSocket::waitForConnected(QSslSocket* theWrappedObject, int msecs) | ||||
{ | ||||
return ( theWrappedObject->waitForConnected(msecs)); | ||||
} | ||||
QList<QSslCertificate > PythonQtWrapper_QSslSocket::static_QSslSocket_systemCaCertificates() | ||||
{ | ||||
return (QSslSocket::systemCaCertificates()); | ||||
} | ||||
bool PythonQtWrapper_QSslSocket::waitForReadyRead(QSslSocket* theWrappedObject, int msecs) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QSslSocket*)theWrappedObject)->promoted_waitForReadyRead(msecs)); | ||||
} | ||||
QSslCertificate PythonQtWrapper_QSslSocket::localCertificate(QSslSocket* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->localCertificate()); | ||||
} | ||||
bool PythonQtWrapper_QSslSocket::waitForEncrypted(QSslSocket* theWrappedObject, int msecs) | ||||
{ | ||||
return ( theWrappedObject->waitForEncrypted(msecs)); | ||||
} | ||||
QVariant PythonQtWrapper_QSslSocket::socketOption(QSslSocket* theWrappedObject, QAbstractSocket::SocketOption option) | ||||
{ | ||||
return ( theWrappedObject->socketOption(option)); | ||||
} | ||||
QList<QSslCertificate > PythonQtWrapper_QSslSocket::peerCertificateChain(QSslSocket* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->peerCertificateChain()); | ||||
} | ||||
QSsl::SslProtocol PythonQtWrapper_QSslSocket::protocol(QSslSocket* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->protocol()); | ||||
} | ||||
int PythonQtWrapper_QSslSocket::peerVerifyDepth(QSslSocket* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->peerVerifyDepth()); | ||||
} | ||||
void PythonQtWrapper_QSslSocket::static_QSslSocket_addDefaultCaCertificates(const QList<QSslCertificate >& certificates) | ||||
{ | ||||
(QSslSocket::addDefaultCaCertificates(certificates)); | ||||
} | ||||
bool PythonQtWrapper_QSslSocket::static_QSslSocket_addDefaultCaCertificates(const QString& path, QSsl::EncodingFormat format, QRegExp::PatternSyntax syntax) | ||||
{ | ||||
return (QSslSocket::addDefaultCaCertificates(path, format, syntax)); | ||||
} | ||||
QList<QSslCipher > PythonQtWrapper_QSslSocket::ciphers(QSslSocket* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->ciphers()); | ||||
} | ||||
QTcpSocket* PythonQtShell_QTcpServer::nextPendingConnection() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "nextPendingConnection"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"QTcpSocket*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
QTcpSocket* returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("nextPendingConnection", methodInfo, result); | ||||
} else { | ||||
returnValue = *((QTcpSocket**)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTcpServer::nextPendingConnection(); | ||||
} | ||||
bool PythonQtShell_QTcpServer::hasPendingConnections() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "hasPendingConnections"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
bool returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("hasPendingConnections", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTcpServer::hasPendingConnections(); | ||||
} | ||||
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"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&handle}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTcpServer::incomingConnection(handle); | ||||
} | ||||
florianlink
|
r117 | void PythonQtShell_QTcpServer::childEvent(QChildEvent* arg__1) | ||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QChildEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTcpServer::childEvent(arg__1); | ||||
} | ||||
florianlink
|
r110 | 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); | ||||
} | ||||
florianlink
|
r117 | void PythonQtShell_QTcpServer::customEvent(QEvent* arg__1) | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r117 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r117 | static const char* argumentList[] ={"" , "QEvent*"}; | ||
florianlink
|
r110 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r117 | QTcpServer::customEvent(arg__1); | ||
florianlink
|
r110 | } | ||
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); | ||||
} | ||||
QTcpServer* PythonQtWrapper_QTcpServer::new_QTcpServer(QObject* parent) | ||||
{ | ||||
return new PythonQtShell_QTcpServer(parent); } | ||||
int PythonQtWrapper_QTcpServer::maxPendingConnections(QTcpServer* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->maxPendingConnections()); | ||||
} | ||||
QAbstractSocket::SocketError PythonQtWrapper_QTcpServer::serverError(QTcpServer* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->serverError()); | ||||
} | ||||
bool PythonQtWrapper_QTcpServer::waitForNewConnection(QTcpServer* theWrappedObject, int msec, bool* timedOut) | ||||
{ | ||||
return ( theWrappedObject->waitForNewConnection(msec, timedOut)); | ||||
} | ||||
bool PythonQtWrapper_QTcpServer::isListening(QTcpServer* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isListening()); | ||||
} | ||||
unsigned short PythonQtWrapper_QTcpServer::serverPort(QTcpServer* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->serverPort()); | ||||
} | ||||
QTcpSocket* PythonQtWrapper_QTcpServer::nextPendingConnection(QTcpServer* theWrappedObject) | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTcpServer*)theWrappedObject)->promoted_nextPendingConnection()); | ||||
} | ||||
void PythonQtWrapper_QTcpServer::close(QTcpServer* theWrappedObject) | ||||
{ | ||||
( theWrappedObject->close()); | ||||
} | ||||
void PythonQtWrapper_QTcpServer::setProxy(QTcpServer* theWrappedObject, const QNetworkProxy& networkProxy) | ||||
{ | ||||
( theWrappedObject->setProxy(networkProxy)); | ||||
} | ||||
QNetworkProxy PythonQtWrapper_QTcpServer::proxy(QTcpServer* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->proxy()); | ||||
} | ||||
QHostAddress PythonQtWrapper_QTcpServer::serverAddress(QTcpServer* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->serverAddress()); | ||||
} | ||||
int PythonQtWrapper_QTcpServer::socketDescriptor(QTcpServer* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->socketDescriptor()); | ||||
} | ||||
bool PythonQtWrapper_QTcpServer::setSocketDescriptor(QTcpServer* theWrappedObject, int socketDescriptor) | ||||
{ | ||||
return ( theWrappedObject->setSocketDescriptor(socketDescriptor)); | ||||
} | ||||
void PythonQtWrapper_QTcpServer::setMaxPendingConnections(QTcpServer* theWrappedObject, int numConnections) | ||||
{ | ||||
( theWrappedObject->setMaxPendingConnections(numConnections)); | ||||
} | ||||
bool PythonQtWrapper_QTcpServer::listen(QTcpServer* theWrappedObject, const QHostAddress& address, unsigned short port) | ||||
{ | ||||
return ( theWrappedObject->listen(address, port)); | ||||
} | ||||
bool PythonQtWrapper_QTcpServer::hasPendingConnections(QTcpServer* theWrappedObject) const | ||||
{ | ||||
return ( ((PythonQtPublicPromoter_QTcpServer*)theWrappedObject)->promoted_hasPendingConnections()); | ||||
} | ||||
QString PythonQtWrapper_QTcpServer::errorString(QTcpServer* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->errorString()); | ||||
} | ||||
void PythonQtWrapper_QTcpServer::incomingConnection(QTcpServer* theWrappedObject, int handle) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QTcpServer*)theWrappedObject)->promoted_incomingConnection(handle)); | ||||
} | ||||
florianlink
|
r117 | qint64 PythonQtShell_QTcpSocket::bytesAvailable() const | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r117 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "bytesAvailable"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r117 | static const char* argumentList[] ={"qint64"}; | ||
florianlink
|
r110 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||
florianlink
|
r117 | qint64 returnValue; | ||
florianlink
|
r110 | 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
|
r117 | PythonQt::priv()->handleVirtualOverloadReturnError("bytesAvailable", methodInfo, result); | ||
florianlink
|
r110 | } else { | ||
florianlink
|
r117 | returnValue = *((qint64*)args[0]); | ||
florianlink
|
r110 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r117 | return QTcpSocket::bytesAvailable(); | ||
florianlink
|
r110 | } | ||
florianlink
|
r117 | bool PythonQtShell_QTcpSocket::waitForBytesWritten(int msecs) | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r117 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "waitForBytesWritten"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r117 | 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
|
r117 | PythonQt::priv()->handleVirtualOverloadReturnError("waitForBytesWritten", methodInfo, result); | ||
florianlink
|
r110 | } else { | ||
florianlink
|
r117 | returnValue = *((bool*)args[0]); | ||
florianlink
|
r110 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r117 | return QTcpSocket::waitForBytesWritten(msecs); | ||
florianlink
|
r110 | } | ||
florianlink
|
r117 | bool PythonQtShell_QTcpSocket::isSequential() const | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r117 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isSequential"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r117 | static const char* argumentList[] ={"bool"}; | ||
florianlink
|
r110 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||
florianlink
|
r117 | bool returnValue; | ||
florianlink
|
r110 | 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
|
r117 | PythonQt::priv()->handleVirtualOverloadReturnError("isSequential", methodInfo, result); | ||
florianlink
|
r110 | } else { | ||
florianlink
|
r117 | returnValue = *((bool*)args[0]); | ||
florianlink
|
r110 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r117 | return QTcpSocket::isSequential(); | ||
florianlink
|
r110 | } | ||
florianlink
|
r117 | qint64 PythonQtShell_QTcpSocket::readData(char* data, qint64 maxlen) | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r117 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "readData"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r117 | 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
|
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
|
r117 | PythonQt::priv()->handleVirtualOverloadReturnError("readData", methodInfo, result); | ||
florianlink
|
r110 | } else { | ||
florianlink
|
r117 | returnValue = *((qint64*)args[0]); | ||
florianlink
|
r110 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r117 | return QTcpSocket::readData(data, maxlen); | ||
florianlink
|
r110 | } | ||
florianlink
|
r117 | bool PythonQtShell_QTcpSocket::reset() | ||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reset"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
bool returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("reset", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTcpSocket::reset(); | ||||
} | ||||
qint64 PythonQtShell_QTcpSocket::bytesToWrite() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "bytesToWrite"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"qint64"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
qint64 returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("bytesToWrite", methodInfo, result); | ||||
} else { | ||||
returnValue = *((qint64*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTcpSocket::bytesToWrite(); | ||||
} | ||||
bool PythonQtShell_QTcpSocket::waitForReadyRead(int msecs) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "waitForReadyRead"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&msecs}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("waitForReadyRead", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTcpSocket::waitForReadyRead(msecs); | ||||
} | ||||
qint64 PythonQtShell_QTcpSocket::writeData(const char* data, qint64 len) | ||||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "writeData"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"qint64" , "const char*" , "qint64"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
qint64 returnValue; | ||||
void* args[3] = {NULL, (void*)&data, (void*)&len}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("writeData", methodInfo, result); | ||||
} else { | ||||
returnValue = *((qint64*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTcpSocket::writeData(data, len); | ||||
} | ||||
bool PythonQtShell_QTcpSocket::canReadLine() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "canReadLine"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
bool returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("canReadLine", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTcpSocket::canReadLine(); | ||||
} | ||||
void PythonQtShell_QTcpSocket::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(); | ||||
} | ||||
bool PythonQtShell_QTcpSocket::atEnd() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "atEnd"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
bool returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("atEnd", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTcpSocket::atEnd(); | ||||
} | ||||
qint64 PythonQtShell_QTcpSocket::readLineData(char* data, qint64 maxlen) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "readLineData"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"qint64" , "char*" , "qint64"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
qint64 returnValue; | ||||
void* args[3] = {NULL, (void*)&data, (void*)&maxlen}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("readLineData", methodInfo, result); | ||||
} else { | ||||
returnValue = *((qint64*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTcpSocket::readLineData(data, maxlen); | ||||
} | ||||
florianlink
|
r117 | qint64 PythonQtShell_QTcpSocket::size() const | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r117 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "size"); | ||
florianlink
|
r110 | 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
|
r117 | PythonQt::priv()->handleVirtualOverloadReturnError("size", methodInfo, result); | ||
florianlink
|
r110 | } else { | ||
returnValue = *((qint64*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r117 | return QTcpSocket::size(); | ||
florianlink
|
r110 | } | ||
florianlink
|
r117 | qint64 PythonQtShell_QTcpSocket::pos() const | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r117 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "pos"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r117 | static const char* argumentList[] ={"qint64"}; | ||
florianlink
|
r110 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||
florianlink
|
r117 | qint64 returnValue; | ||
florianlink
|
r110 | 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
|
r117 | PythonQt::priv()->handleVirtualOverloadReturnError("pos", methodInfo, result); | ||
florianlink
|
r110 | } else { | ||
florianlink
|
r117 | returnValue = *((qint64*)args[0]); | ||
florianlink
|
r110 | } | ||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r117 | return QTcpSocket::pos(); | ||
florianlink
|
r110 | } | ||
bool PythonQtShell_QTcpSocket::open(QIODevice::OpenMode mode) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "open"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "QIODevice::OpenMode"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&mode}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("open", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTcpSocket::open(mode); | ||||
} | ||||
bool PythonQtShell_QTcpSocket::seek(qint64 pos) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "seek"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "qint64"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&pos}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("seek", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTcpSocket::seek(pos); | ||||
} | ||||
florianlink
|
r117 | void PythonQtShell_QTcpSocket::childEvent(QChildEvent* arg__1) | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r117 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r117 | static const char* argumentList[] ={"" , "QChildEvent*"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
florianlink
|
r110 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
florianlink
|
r117 | return; | ||
florianlink
|
r110 | } | ||
} | ||||
florianlink
|
r117 | QTcpSocket::childEvent(arg__1); | ||
florianlink
|
r110 | } | ||
void PythonQtShell_QTcpSocket::timerEvent(QTimerEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QTimerEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QTcpSocket::timerEvent(arg__1); | ||||
} | ||||
florianlink
|
r117 | void PythonQtShell_QTcpSocket::customEvent(QEvent* arg__1) | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r117 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r117 | static const char* argumentList[] ={"" , "QEvent*"}; | ||
florianlink
|
r110 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r117 | QTcpSocket::customEvent(arg__1); | ||
florianlink
|
r110 | } | ||
bool PythonQtShell_QTcpSocket::event(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "QEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTcpSocket::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QTcpSocket::eventFilter(QObject* arg__1, QEvent* arg__2) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
bool returnValue; | ||||
void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QTcpSocket::eventFilter(arg__1, arg__2); | ||||
} | ||||
QTcpSocket* PythonQtWrapper_QTcpSocket::new_QTcpSocket(QObject* parent) | ||||
{ | ||||
return new PythonQtShell_QTcpSocket(parent); } | ||||
florianlink
|
r117 | qint64 PythonQtShell_QUdpSocket::bytesAvailable() const | ||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "bytesAvailable"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"qint64"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
qint64 returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("bytesAvailable", methodInfo, result); | ||||
} else { | ||||
returnValue = *((qint64*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QUdpSocket::bytesAvailable(); | ||||
} | ||||
bool PythonQtShell_QUdpSocket::waitForBytesWritten(int msecs) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "waitForBytesWritten"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&msecs}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("waitForBytesWritten", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QUdpSocket::waitForBytesWritten(msecs); | ||||
} | ||||
qint64 PythonQtShell_QUdpSocket::size() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "size"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"qint64"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
qint64 returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("size", methodInfo, result); | ||||
} else { | ||||
returnValue = *((qint64*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QUdpSocket::size(); | ||||
} | ||||
florianlink
|
r110 | bool PythonQtShell_QUdpSocket::isSequential() const | ||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isSequential"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
bool returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("isSequential", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QUdpSocket::isSequential(); | ||||
} | ||||
qint64 PythonQtShell_QUdpSocket::readData(char* data, qint64 maxlen) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "readData"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"qint64" , "char*" , "qint64"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
qint64 returnValue; | ||||
void* args[3] = {NULL, (void*)&data, (void*)&maxlen}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("readData", methodInfo, result); | ||||
} else { | ||||
returnValue = *((qint64*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QUdpSocket::readData(data, maxlen); | ||||
} | ||||
qint64 PythonQtShell_QUdpSocket::bytesToWrite() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "bytesToWrite"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"qint64"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
qint64 returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("bytesToWrite", methodInfo, result); | ||||
} else { | ||||
returnValue = *((qint64*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QUdpSocket::bytesToWrite(); | ||||
} | ||||
bool PythonQtShell_QUdpSocket::waitForReadyRead(int msecs) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "waitForReadyRead"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&msecs}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("waitForReadyRead", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QUdpSocket::waitForReadyRead(msecs); | ||||
} | ||||
qint64 PythonQtShell_QUdpSocket::writeData(const char* data, qint64 len) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "writeData"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"qint64" , "const char*" , "qint64"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
qint64 returnValue; | ||||
void* args[3] = {NULL, (void*)&data, (void*)&len}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("writeData", methodInfo, result); | ||||
} else { | ||||
returnValue = *((qint64*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QUdpSocket::writeData(data, len); | ||||
} | ||||
bool PythonQtShell_QUdpSocket::canReadLine() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "canReadLine"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
bool returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("canReadLine", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QUdpSocket::canReadLine(); | ||||
} | ||||
void PythonQtShell_QUdpSocket::close() | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "close"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={""}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QUdpSocket::close(); | ||||
} | ||||
bool PythonQtShell_QUdpSocket::atEnd() const | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "atEnd"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList); | ||||
bool returnValue; | ||||
void* args[1] = {NULL}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("atEnd", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QUdpSocket::atEnd(); | ||||
} | ||||
qint64 PythonQtShell_QUdpSocket::readLineData(char* data, qint64 maxlen) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "readLineData"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"qint64" , "char*" , "qint64"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
qint64 returnValue; | ||||
void* args[3] = {NULL, (void*)&data, (void*)&maxlen}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("readLineData", methodInfo, result); | ||||
} else { | ||||
returnValue = *((qint64*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QUdpSocket::readLineData(data, maxlen); | ||||
} | ||||
florianlink
|
r117 | qint64 PythonQtShell_QUdpSocket::pos() const | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r117 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "pos"); | ||
florianlink
|
r110 | 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
|
r117 | PythonQt::priv()->handleVirtualOverloadReturnError("pos", methodInfo, result); | ||
florianlink
|
r110 | } else { | ||
returnValue = *((qint64*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r117 | return QUdpSocket::pos(); | ||
florianlink
|
r110 | } | ||
florianlink
|
r117 | bool PythonQtShell_QUdpSocket::reset() | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r117 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reset"); | ||
florianlink
|
r110 | 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
|
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
|
r117 | PythonQt::priv()->handleVirtualOverloadReturnError("reset", methodInfo, result); | ||
florianlink
|
r110 | } else { | ||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r117 | return QUdpSocket::reset(); | ||
florianlink
|
r110 | } | ||
florianlink
|
r117 | bool PythonQtShell_QUdpSocket::open(QIODevice::OpenMode mode) | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r117 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "open"); | ||
florianlink
|
r110 | 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
|
r110 | bool returnValue; | ||
florianlink
|
r117 | void* args[2] = {NULL, (void*)&mode}; | ||
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
|
r117 | PythonQt::priv()->handleVirtualOverloadReturnError("open", methodInfo, result); | ||
florianlink
|
r110 | } else { | ||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
florianlink
|
r117 | return QUdpSocket::open(mode); | ||
florianlink
|
r110 | } | ||
bool PythonQtShell_QUdpSocket::seek(qint64 pos) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "seek"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "qint64"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&pos}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("seek", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QUdpSocket::seek(pos); | ||||
} | ||||
florianlink
|
r117 | void PythonQtShell_QUdpSocket::childEvent(QChildEvent* arg__1) | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r117 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r117 | static const char* argumentList[] ={"" , "QChildEvent*"}; | ||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
florianlink
|
r110 | PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
florianlink
|
r117 | return; | ||
florianlink
|
r110 | } | ||
} | ||||
florianlink
|
r117 | QUdpSocket::childEvent(arg__1); | ||
florianlink
|
r110 | } | ||
void PythonQtShell_QUdpSocket::timerEvent(QTimerEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "timerEvent"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "QTimerEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QUdpSocket::timerEvent(arg__1); | ||||
} | ||||
florianlink
|
r117 | void PythonQtShell_QUdpSocket::customEvent(QEvent* arg__1) | ||
florianlink
|
r110 | { | ||
if (_wrapper) { | ||||
florianlink
|
r117 | PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent"); | ||
florianlink
|
r110 | PyErr_Clear(); | ||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
florianlink
|
r117 | static const char* argumentList[] ={"" , "QEvent*"}; | ||
florianlink
|
r110 | static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
florianlink
|
r117 | QUdpSocket::customEvent(arg__1); | ||
florianlink
|
r110 | } | ||
bool PythonQtShell_QUdpSocket::event(QEvent* arg__1) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "QEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
bool returnValue; | ||||
void* args[2] = {NULL, (void*)&arg__1}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QUdpSocket::event(arg__1); | ||||
} | ||||
bool PythonQtShell_QUdpSocket::eventFilter(QObject* arg__1, QEvent* arg__2) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList); | ||||
bool returnValue; | ||||
void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { | ||||
args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue); | ||||
if (args[0]!=&returnValue) { | ||||
if (args[0]==NULL) { | ||||
PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result); | ||||
} else { | ||||
returnValue = *((bool*)args[0]); | ||||
} | ||||
} | ||||
} | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return returnValue; | ||||
} | ||||
} | ||||
return QUdpSocket::eventFilter(arg__1, arg__2); | ||||
} | ||||
QUdpSocket* PythonQtWrapper_QUdpSocket::new_QUdpSocket(QObject* parent) | ||||
{ | ||||
return new PythonQtShell_QUdpSocket(parent); } | ||||
qint64 PythonQtWrapper_QUdpSocket::writeDatagram(QUdpSocket* theWrappedObject, const QByteArray& datagram, const QHostAddress& host, unsigned short port) | ||||
{ | ||||
return ( theWrappedObject->writeDatagram(datagram, host, port)); | ||||
} | ||||
bool PythonQtWrapper_QUdpSocket::bind(QUdpSocket* theWrappedObject, unsigned short port) | ||||
{ | ||||
return ( theWrappedObject->bind(port)); | ||||
} | ||||
bool PythonQtWrapper_QUdpSocket::hasPendingDatagrams(QUdpSocket* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->hasPendingDatagrams()); | ||||
} | ||||
qint64 PythonQtWrapper_QUdpSocket::pendingDatagramSize(QUdpSocket* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->pendingDatagramSize()); | ||||
} | ||||
bool PythonQtWrapper_QUdpSocket::bind(QUdpSocket* theWrappedObject, unsigned short port, QUdpSocket::BindMode mode) | ||||
{ | ||||
return ( theWrappedObject->bind(port, mode)); | ||||
} | ||||
bool PythonQtWrapper_QUdpSocket::bind(QUdpSocket* theWrappedObject, const QHostAddress& address, unsigned short port, QUdpSocket::BindMode mode) | ||||
{ | ||||
return ( theWrappedObject->bind(address, port, mode)); | ||||
} | ||||
bool PythonQtWrapper_QUdpSocket::bind(QUdpSocket* theWrappedObject, const QHostAddress& address, unsigned short port) | ||||
{ | ||||
return ( theWrappedObject->bind(address, port)); | ||||
} | ||||
qint64 PythonQtWrapper_QUdpSocket::readDatagram(QUdpSocket* theWrappedObject, char* data, qint64 maxlen, QHostAddress* host, unsigned short* port) | ||||
{ | ||||
return ( theWrappedObject->readDatagram(data, maxlen, host, port)); | ||||
} | ||||
void PythonQtShell_QUrlInfo::setWritable(bool b) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setWritable"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&b}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QUrlInfo::setWritable(b); | ||||
} | ||||
void PythonQtShell_QUrlInfo::setName(const QString& name) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setName"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "const QString&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&name}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QUrlInfo::setName(name); | ||||
} | ||||
void PythonQtShell_QUrlInfo::setReadable(bool b) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setReadable"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&b}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QUrlInfo::setReadable(b); | ||||
} | ||||
void PythonQtShell_QUrlInfo::setGroup(const QString& s) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setGroup"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "const QString&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&s}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QUrlInfo::setGroup(s); | ||||
} | ||||
void PythonQtShell_QUrlInfo::setSize(qint64 size) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setSize"); | ||||
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; | ||||
} | ||||
} | ||||
QUrlInfo::setSize(size); | ||||
} | ||||
void PythonQtShell_QUrlInfo::setFile(bool b) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setFile"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&b}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QUrlInfo::setFile(b); | ||||
} | ||||
void PythonQtShell_QUrlInfo::setLastModified(const QDateTime& dt) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setLastModified"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "const QDateTime&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&dt}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QUrlInfo::setLastModified(dt); | ||||
} | ||||
void PythonQtShell_QUrlInfo::setDir(bool b) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setDir"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&b}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QUrlInfo::setDir(b); | ||||
} | ||||
void PythonQtShell_QUrlInfo::setPermissions(int p) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setPermissions"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "int"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&p}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QUrlInfo::setPermissions(p); | ||||
} | ||||
void PythonQtShell_QUrlInfo::setOwner(const QString& s) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setOwner"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "const QString&"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&s}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QUrlInfo::setOwner(s); | ||||
} | ||||
void PythonQtShell_QUrlInfo::setSymLink(bool b) | ||||
{ | ||||
if (_wrapper) { | ||||
PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "setSymLink"); | ||||
PyErr_Clear(); | ||||
if (obj && !PythonQtSlotFunction_Check(obj)) { | ||||
static const char* argumentList[] ={"" , "bool"}; | ||||
static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList); | ||||
void* args[2] = {NULL, (void*)&b}; | ||||
PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true); | ||||
if (result) { Py_DECREF(result); } | ||||
Py_DECREF(obj); | ||||
return; | ||||
} | ||||
} | ||||
QUrlInfo::setSymLink(b); | ||||
} | ||||
QUrlInfo* PythonQtWrapper_QUrlInfo::new_QUrlInfo() | ||||
{ | ||||
return new PythonQtShell_QUrlInfo(); } | ||||
QUrlInfo* PythonQtWrapper_QUrlInfo::new_QUrlInfo(const QString& name, int permissions, const QString& owner, const QString& group, qint64 size, const QDateTime& lastModified, const QDateTime& lastRead, bool isDir, bool isFile, bool isSymLink, bool isWritable, bool isReadable, bool isExecutable) | ||||
{ | ||||
return new PythonQtShell_QUrlInfo(name, permissions, owner, group, size, lastModified, lastRead, isDir, isFile, isSymLink, isWritable, isReadable, isExecutable); } | ||||
QUrlInfo* PythonQtWrapper_QUrlInfo::new_QUrlInfo(const QUrl& url, int permissions, const QString& owner, const QString& group, qint64 size, const QDateTime& lastModified, const QDateTime& lastRead, bool isDir, bool isFile, bool isSymLink, bool isWritable, bool isReadable, bool isExecutable) | ||||
{ | ||||
return new PythonQtShell_QUrlInfo(url, permissions, owner, group, size, lastModified, lastRead, isDir, isFile, isSymLink, isWritable, isReadable, isExecutable); } | ||||
QUrlInfo* PythonQtWrapper_QUrlInfo::new_QUrlInfo(const QUrlInfo& ui) | ||||
{ | ||||
return new PythonQtShell_QUrlInfo(ui); } | ||||
bool PythonQtWrapper_QUrlInfo::isValid(QUrlInfo* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isValid()); | ||||
} | ||||
bool PythonQtWrapper_QUrlInfo::isWritable(QUrlInfo* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isWritable()); | ||||
} | ||||
void PythonQtWrapper_QUrlInfo::setWritable(QUrlInfo* theWrappedObject, bool b) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QUrlInfo*)theWrappedObject)->promoted_setWritable(b)); | ||||
} | ||||
florianlink
|
r117 | bool PythonQtWrapper_QUrlInfo::static_QUrlInfo_equal(const QUrlInfo& i1, const QUrlInfo& i2, int sortBy) | ||
{ | ||||
return (QUrlInfo::equal(i1, i2, sortBy)); | ||||
} | ||||
florianlink
|
r110 | void PythonQtWrapper_QUrlInfo::setName(QUrlInfo* theWrappedObject, const QString& name) | ||
{ | ||||
( ((PythonQtPublicPromoter_QUrlInfo*)theWrappedObject)->promoted_setName(name)); | ||||
} | ||||
void PythonQtWrapper_QUrlInfo::setReadable(QUrlInfo* theWrappedObject, bool b) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QUrlInfo*)theWrappedObject)->promoted_setReadable(b)); | ||||
} | ||||
bool PythonQtWrapper_QUrlInfo::isDir(QUrlInfo* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isDir()); | ||||
} | ||||
florianlink
|
r117 | QString PythonQtWrapper_QUrlInfo::name(QUrlInfo* theWrappedObject) const | ||
florianlink
|
r110 | { | ||
florianlink
|
r117 | return ( theWrappedObject->name()); | ||
florianlink
|
r110 | } | ||
void PythonQtWrapper_QUrlInfo::setLastRead(QUrlInfo* theWrappedObject, const QDateTime& dt) | ||||
{ | ||||
( theWrappedObject->setLastRead(dt)); | ||||
} | ||||
void PythonQtWrapper_QUrlInfo::setGroup(QUrlInfo* theWrappedObject, const QString& s) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QUrlInfo*)theWrappedObject)->promoted_setGroup(s)); | ||||
} | ||||
bool PythonQtWrapper_QUrlInfo::isExecutable(QUrlInfo* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isExecutable()); | ||||
} | ||||
QDateTime PythonQtWrapper_QUrlInfo::lastModified(QUrlInfo* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->lastModified()); | ||||
} | ||||
bool PythonQtWrapper_QUrlInfo::static_QUrlInfo_greaterThan(const QUrlInfo& i1, const QUrlInfo& i2, int sortBy) | ||||
{ | ||||
return (QUrlInfo::greaterThan(i1, i2, sortBy)); | ||||
} | ||||
void PythonQtWrapper_QUrlInfo::setSize(QUrlInfo* theWrappedObject, qint64 size) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QUrlInfo*)theWrappedObject)->promoted_setSize(size)); | ||||
} | ||||
QString PythonQtWrapper_QUrlInfo::owner(QUrlInfo* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->owner()); | ||||
} | ||||
bool PythonQtWrapper_QUrlInfo::operator_equal(QUrlInfo* theWrappedObject, const QUrlInfo& i) const | ||||
{ | ||||
return ( (*theWrappedObject)== i); | ||||
} | ||||
void PythonQtWrapper_QUrlInfo::setFile(QUrlInfo* theWrappedObject, bool b) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QUrlInfo*)theWrappedObject)->promoted_setFile(b)); | ||||
} | ||||
bool PythonQtWrapper_QUrlInfo::isSymLink(QUrlInfo* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isSymLink()); | ||||
} | ||||
void PythonQtWrapper_QUrlInfo::setLastModified(QUrlInfo* theWrappedObject, const QDateTime& dt) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QUrlInfo*)theWrappedObject)->promoted_setLastModified(dt)); | ||||
} | ||||
void PythonQtWrapper_QUrlInfo::setDir(QUrlInfo* theWrappedObject, bool b) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QUrlInfo*)theWrappedObject)->promoted_setDir(b)); | ||||
} | ||||
void PythonQtWrapper_QUrlInfo::setPermissions(QUrlInfo* theWrappedObject, int p) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QUrlInfo*)theWrappedObject)->promoted_setPermissions(p)); | ||||
} | ||||
bool PythonQtWrapper_QUrlInfo::isFile(QUrlInfo* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isFile()); | ||||
} | ||||
bool PythonQtWrapper_QUrlInfo::isReadable(QUrlInfo* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->isReadable()); | ||||
} | ||||
void PythonQtWrapper_QUrlInfo::setOwner(QUrlInfo* theWrappedObject, const QString& s) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QUrlInfo*)theWrappedObject)->promoted_setOwner(s)); | ||||
} | ||||
QString PythonQtWrapper_QUrlInfo::group(QUrlInfo* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->group()); | ||||
} | ||||
qint64 PythonQtWrapper_QUrlInfo::size(QUrlInfo* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->size()); | ||||
} | ||||
bool PythonQtWrapper_QUrlInfo::static_QUrlInfo_lessThan(const QUrlInfo& i1, const QUrlInfo& i2, int sortBy) | ||||
{ | ||||
return (QUrlInfo::lessThan(i1, i2, sortBy)); | ||||
} | ||||
QDateTime PythonQtWrapper_QUrlInfo::lastRead(QUrlInfo* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->lastRead()); | ||||
} | ||||
int PythonQtWrapper_QUrlInfo::permissions(QUrlInfo* theWrappedObject) const | ||||
{ | ||||
return ( theWrappedObject->permissions()); | ||||
} | ||||
void PythonQtWrapper_QUrlInfo::setSymLink(QUrlInfo* theWrappedObject, bool b) | ||||
{ | ||||
( ((PythonQtPublicPromoter_QUrlInfo*)theWrappedObject)->promoted_setSymLink(b)); | ||||
} | ||||