2041 lines
78 KiB
Diff
2041 lines
78 KiB
Diff
|
diff --git a/3rdparty/pythonqt/generated_cpp/com_trolltech_qt_network/com_trolltech_qt_network1.cpp b/3rdparty/pythonqt/generated_cpp/com_trolltech_qt_network/com_trolltech_qt_network1.cpp
|
||
|
index 8c323fb..06d867b 100644
|
||
|
--- a/3rdparty/pythonqt/generated_cpp/com_trolltech_qt_network/com_trolltech_qt_network1.cpp
|
||
|
+++ b/3rdparty/pythonqt/generated_cpp/com_trolltech_qt_network/com_trolltech_qt_network1.cpp
|
||
|
@@ -18,11 +18,7 @@
|
||
|
#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()
|
||
|
{
|
||
|
@@ -953,1769 +949,3 @@ QList<QSslCipher > PythonQtWrapper_QSslSocket::ciphers(QSslSocket* theWrappedOb
|
||
|
}
|
||
|
|
||
|
|
||
|
-
|
||
|
-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);
|
||
|
-}
|
||
|
-void PythonQtShell_QTcpServer::childEvent(QChildEvent* arg__1)
|
||
|
-{
|
||
|
-if (_wrapper) {
|
||
|
- PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
|
||
|
- PyErr_Clear();
|
||
|
- if (obj && !PythonQtSlotFunction_Check(obj)) {
|
||
|
- static const char* argumentList[] ={"" , "QChildEvent*"};
|
||
|
- static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
||
|
- void* args[2] = {NULL, (void*)&arg__1};
|
||
|
- PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
||
|
- if (result) { Py_DECREF(result); }
|
||
|
- Py_DECREF(obj);
|
||
|
- return;
|
||
|
- }
|
||
|
-}
|
||
|
- QTcpServer::childEvent(arg__1);
|
||
|
-}
|
||
|
-void PythonQtShell_QTcpServer::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);
|
||
|
-}
|
||
|
-void PythonQtShell_QTcpServer::customEvent(QEvent* arg__1)
|
||
|
-{
|
||
|
-if (_wrapper) {
|
||
|
- PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
|
||
|
- PyErr_Clear();
|
||
|
- if (obj && !PythonQtSlotFunction_Check(obj)) {
|
||
|
- static const char* argumentList[] ={"" , "QEvent*"};
|
||
|
- static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
||
|
- void* args[2] = {NULL, (void*)&arg__1};
|
||
|
- PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
||
|
- if (result) { Py_DECREF(result); }
|
||
|
- Py_DECREF(obj);
|
||
|
- return;
|
||
|
- }
|
||
|
-}
|
||
|
- QTcpServer::customEvent(arg__1);
|
||
|
-}
|
||
|
-bool PythonQtShell_QTcpServer::event(QEvent* arg__1)
|
||
|
-{
|
||
|
-if (_wrapper) {
|
||
|
- PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
|
||
|
- PyErr_Clear();
|
||
|
- if (obj && !PythonQtSlotFunction_Check(obj)) {
|
||
|
- static const char* argumentList[] ={"bool" , "QEvent*"};
|
||
|
- static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
||
|
- bool returnValue;
|
||
|
- void* args[2] = {NULL, (void*)&arg__1};
|
||
|
- PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
||
|
- if (result) {
|
||
|
- args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
||
|
- if (args[0]!=&returnValue) {
|
||
|
- if (args[0]==NULL) {
|
||
|
- PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
|
||
|
- } else {
|
||
|
- returnValue = *((bool*)args[0]);
|
||
|
- }
|
||
|
- }
|
||
|
- }
|
||
|
- if (result) { Py_DECREF(result); }
|
||
|
- Py_DECREF(obj);
|
||
|
- return returnValue;
|
||
|
- }
|
||
|
-}
|
||
|
- return QTcpServer::event(arg__1);
|
||
|
-}
|
||
|
-bool PythonQtShell_QTcpServer::eventFilter(QObject* arg__1, QEvent* arg__2)
|
||
|
-{
|
||
|
-if (_wrapper) {
|
||
|
- PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "eventFilter");
|
||
|
- PyErr_Clear();
|
||
|
- if (obj && !PythonQtSlotFunction_Check(obj)) {
|
||
|
- static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
|
||
|
- static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
||
|
- bool returnValue;
|
||
|
- void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
|
||
|
- PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
||
|
- if (result) {
|
||
|
- args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
||
|
- if (args[0]!=&returnValue) {
|
||
|
- if (args[0]==NULL) {
|
||
|
- PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
|
||
|
- } else {
|
||
|
- returnValue = *((bool*)args[0]);
|
||
|
- }
|
||
|
- }
|
||
|
- }
|
||
|
- if (result) { Py_DECREF(result); }
|
||
|
- Py_DECREF(obj);
|
||
|
- return returnValue;
|
||
|
- }
|
||
|
-}
|
||
|
- return QTcpServer::eventFilter(arg__1, arg__2);
|
||
|
-}
|
||
|
-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));
|
||
|
-}
|
||
|
-
|
||
|
-
|
||
|
-
|
||
|
-qint64 PythonQtShell_QTcpSocket::bytesAvailable() const
|
||
|
-{
|
||
|
-if (_wrapper) {
|
||
|
- PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "bytesAvailable");
|
||
|
- PyErr_Clear();
|
||
|
- if (obj && !PythonQtSlotFunction_Check(obj)) {
|
||
|
- static const char* argumentList[] ={"qint64"};
|
||
|
- static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
||
|
- qint64 returnValue;
|
||
|
- void* args[1] = {NULL};
|
||
|
- PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
||
|
- if (result) {
|
||
|
- args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
||
|
- if (args[0]!=&returnValue) {
|
||
|
- if (args[0]==NULL) {
|
||
|
- PythonQt::priv()->handleVirtualOverloadReturnError("bytesAvailable", methodInfo, result);
|
||
|
- } else {
|
||
|
- returnValue = *((qint64*)args[0]);
|
||
|
- }
|
||
|
- }
|
||
|
- }
|
||
|
- if (result) { Py_DECREF(result); }
|
||
|
- Py_DECREF(obj);
|
||
|
- return returnValue;
|
||
|
- }
|
||
|
-}
|
||
|
- return QTcpSocket::bytesAvailable();
|
||
|
-}
|
||
|
-bool PythonQtShell_QTcpSocket::waitForBytesWritten(int msecs)
|
||
|
-{
|
||
|
-if (_wrapper) {
|
||
|
- PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "waitForBytesWritten");
|
||
|
- PyErr_Clear();
|
||
|
- if (obj && !PythonQtSlotFunction_Check(obj)) {
|
||
|
- static const char* argumentList[] ={"bool" , "int"};
|
||
|
- static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
||
|
- bool returnValue;
|
||
|
- void* args[2] = {NULL, (void*)&msecs};
|
||
|
- PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
||
|
- if (result) {
|
||
|
- args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
||
|
- if (args[0]!=&returnValue) {
|
||
|
- if (args[0]==NULL) {
|
||
|
- PythonQt::priv()->handleVirtualOverloadReturnError("waitForBytesWritten", methodInfo, result);
|
||
|
- } else {
|
||
|
- returnValue = *((bool*)args[0]);
|
||
|
- }
|
||
|
- }
|
||
|
- }
|
||
|
- if (result) { Py_DECREF(result); }
|
||
|
- Py_DECREF(obj);
|
||
|
- return returnValue;
|
||
|
- }
|
||
|
-}
|
||
|
- return QTcpSocket::waitForBytesWritten(msecs);
|
||
|
-}
|
||
|
-bool PythonQtShell_QTcpSocket::isSequential() const
|
||
|
-{
|
||
|
-if (_wrapper) {
|
||
|
- PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "isSequential");
|
||
|
- PyErr_Clear();
|
||
|
- if (obj && !PythonQtSlotFunction_Check(obj)) {
|
||
|
- static const char* argumentList[] ={"bool"};
|
||
|
- static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
||
|
- bool returnValue;
|
||
|
- void* args[1] = {NULL};
|
||
|
- PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
||
|
- if (result) {
|
||
|
- args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
||
|
- if (args[0]!=&returnValue) {
|
||
|
- if (args[0]==NULL) {
|
||
|
- PythonQt::priv()->handleVirtualOverloadReturnError("isSequential", methodInfo, result);
|
||
|
- } else {
|
||
|
- returnValue = *((bool*)args[0]);
|
||
|
- }
|
||
|
- }
|
||
|
- }
|
||
|
- if (result) { Py_DECREF(result); }
|
||
|
- Py_DECREF(obj);
|
||
|
- return returnValue;
|
||
|
- }
|
||
|
-}
|
||
|
- return QTcpSocket::isSequential();
|
||
|
-}
|
||
|
-qint64 PythonQtShell_QTcpSocket::readData(char* data, qint64 maxlen)
|
||
|
-{
|
||
|
-if (_wrapper) {
|
||
|
- PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "readData");
|
||
|
- PyErr_Clear();
|
||
|
- if (obj && !PythonQtSlotFunction_Check(obj)) {
|
||
|
- static const char* argumentList[] ={"qint64" , "char*" , "qint64"};
|
||
|
- static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
|
||
|
- qint64 returnValue;
|
||
|
- void* args[3] = {NULL, (void*)&data, (void*)&maxlen};
|
||
|
- PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
||
|
- if (result) {
|
||
|
- args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
||
|
- if (args[0]!=&returnValue) {
|
||
|
- if (args[0]==NULL) {
|
||
|
- PythonQt::priv()->handleVirtualOverloadReturnError("readData", methodInfo, result);
|
||
|
- } else {
|
||
|
- returnValue = *((qint64*)args[0]);
|
||
|
- }
|
||
|
- }
|
||
|
- }
|
||
|
- if (result) { Py_DECREF(result); }
|
||
|
- Py_DECREF(obj);
|
||
|
- return returnValue;
|
||
|
- }
|
||
|
-}
|
||
|
- return QTcpSocket::readData(data, maxlen);
|
||
|
-}
|
||
|
-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)
|
||
|
-{
|
||
|
-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);
|
||
|
-}
|
||
|
-qint64 PythonQtShell_QTcpSocket::size() const
|
||
|
-{
|
||
|
-if (_wrapper) {
|
||
|
- PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "size");
|
||
|
- PyErr_Clear();
|
||
|
- if (obj && !PythonQtSlotFunction_Check(obj)) {
|
||
|
- static const char* argumentList[] ={"qint64"};
|
||
|
- static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
||
|
- qint64 returnValue;
|
||
|
- void* args[1] = {NULL};
|
||
|
- PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
||
|
- if (result) {
|
||
|
- args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
||
|
- if (args[0]!=&returnValue) {
|
||
|
- if (args[0]==NULL) {
|
||
|
- PythonQt::priv()->handleVirtualOverloadReturnError("size", methodInfo, result);
|
||
|
- } else {
|
||
|
- returnValue = *((qint64*)args[0]);
|
||
|
- }
|
||
|
- }
|
||
|
- }
|
||
|
- if (result) { Py_DECREF(result); }
|
||
|
- Py_DECREF(obj);
|
||
|
- return returnValue;
|
||
|
- }
|
||
|
-}
|
||
|
- return QTcpSocket::size();
|
||
|
-}
|
||
|
-qint64 PythonQtShell_QTcpSocket::pos() const
|
||
|
-{
|
||
|
-if (_wrapper) {
|
||
|
- PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "pos");
|
||
|
- PyErr_Clear();
|
||
|
- if (obj && !PythonQtSlotFunction_Check(obj)) {
|
||
|
- static const char* argumentList[] ={"qint64"};
|
||
|
- static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
||
|
- qint64 returnValue;
|
||
|
- void* args[1] = {NULL};
|
||
|
- PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
||
|
- if (result) {
|
||
|
- args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
||
|
- if (args[0]!=&returnValue) {
|
||
|
- if (args[0]==NULL) {
|
||
|
- PythonQt::priv()->handleVirtualOverloadReturnError("pos", methodInfo, result);
|
||
|
- } else {
|
||
|
- returnValue = *((qint64*)args[0]);
|
||
|
- }
|
||
|
- }
|
||
|
- }
|
||
|
- if (result) { Py_DECREF(result); }
|
||
|
- Py_DECREF(obj);
|
||
|
- return returnValue;
|
||
|
- }
|
||
|
-}
|
||
|
- return QTcpSocket::pos();
|
||
|
-}
|
||
|
-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);
|
||
|
-}
|
||
|
-void PythonQtShell_QTcpSocket::childEvent(QChildEvent* arg__1)
|
||
|
-{
|
||
|
-if (_wrapper) {
|
||
|
- PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
|
||
|
- PyErr_Clear();
|
||
|
- if (obj && !PythonQtSlotFunction_Check(obj)) {
|
||
|
- static const char* argumentList[] ={"" , "QChildEvent*"};
|
||
|
- static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
||
|
- void* args[2] = {NULL, (void*)&arg__1};
|
||
|
- PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
||
|
- if (result) { Py_DECREF(result); }
|
||
|
- Py_DECREF(obj);
|
||
|
- return;
|
||
|
- }
|
||
|
-}
|
||
|
- QTcpSocket::childEvent(arg__1);
|
||
|
-}
|
||
|
-void PythonQtShell_QTcpSocket::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);
|
||
|
-}
|
||
|
-void PythonQtShell_QTcpSocket::customEvent(QEvent* arg__1)
|
||
|
-{
|
||
|
-if (_wrapper) {
|
||
|
- PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
|
||
|
- PyErr_Clear();
|
||
|
- if (obj && !PythonQtSlotFunction_Check(obj)) {
|
||
|
- static const char* argumentList[] ={"" , "QEvent*"};
|
||
|
- static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
||
|
- void* args[2] = {NULL, (void*)&arg__1};
|
||
|
- PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
||
|
- if (result) { Py_DECREF(result); }
|
||
|
- Py_DECREF(obj);
|
||
|
- return;
|
||
|
- }
|
||
|
-}
|
||
|
- QTcpSocket::customEvent(arg__1);
|
||
|
-}
|
||
|
-bool PythonQtShell_QTcpSocket::event(QEvent* arg__1)
|
||
|
-{
|
||
|
-if (_wrapper) {
|
||
|
- PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "event");
|
||
|
- PyErr_Clear();
|
||
|
- if (obj && !PythonQtSlotFunction_Check(obj)) {
|
||
|
- static const char* argumentList[] ={"bool" , "QEvent*"};
|
||
|
- static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
||
|
- bool returnValue;
|
||
|
- void* args[2] = {NULL, (void*)&arg__1};
|
||
|
- PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
||
|
- if (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); }
|
||
|
-
|
||
|
-
|
||
|
-
|
||
|
-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();
|
||
|
-}
|
||
|
-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);
|
||
|
-}
|
||
|
-qint64 PythonQtShell_QUdpSocket::pos() const
|
||
|
-{
|
||
|
-if (_wrapper) {
|
||
|
- PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "pos");
|
||
|
- PyErr_Clear();
|
||
|
- if (obj && !PythonQtSlotFunction_Check(obj)) {
|
||
|
- static const char* argumentList[] ={"qint64"};
|
||
|
- static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
||
|
- qint64 returnValue;
|
||
|
- void* args[1] = {NULL};
|
||
|
- PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
||
|
- if (result) {
|
||
|
- args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
||
|
- if (args[0]!=&returnValue) {
|
||
|
- if (args[0]==NULL) {
|
||
|
- PythonQt::priv()->handleVirtualOverloadReturnError("pos", methodInfo, result);
|
||
|
- } else {
|
||
|
- returnValue = *((qint64*)args[0]);
|
||
|
- }
|
||
|
- }
|
||
|
- }
|
||
|
- if (result) { Py_DECREF(result); }
|
||
|
- Py_DECREF(obj);
|
||
|
- return returnValue;
|
||
|
- }
|
||
|
-}
|
||
|
- return QUdpSocket::pos();
|
||
|
-}
|
||
|
-bool PythonQtShell_QUdpSocket::reset()
|
||
|
-{
|
||
|
-if (_wrapper) {
|
||
|
- PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "reset");
|
||
|
- PyErr_Clear();
|
||
|
- if (obj && !PythonQtSlotFunction_Check(obj)) {
|
||
|
- static const char* argumentList[] ={"bool"};
|
||
|
- static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
|
||
|
- bool returnValue;
|
||
|
- void* args[1] = {NULL};
|
||
|
- PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
||
|
- if (result) {
|
||
|
- args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
||
|
- if (args[0]!=&returnValue) {
|
||
|
- if (args[0]==NULL) {
|
||
|
- PythonQt::priv()->handleVirtualOverloadReturnError("reset", methodInfo, result);
|
||
|
- } else {
|
||
|
- returnValue = *((bool*)args[0]);
|
||
|
- }
|
||
|
- }
|
||
|
- }
|
||
|
- if (result) { Py_DECREF(result); }
|
||
|
- Py_DECREF(obj);
|
||
|
- return returnValue;
|
||
|
- }
|
||
|
-}
|
||
|
- return QUdpSocket::reset();
|
||
|
-}
|
||
|
-bool PythonQtShell_QUdpSocket::open(QIODevice::OpenMode mode)
|
||
|
-{
|
||
|
-if (_wrapper) {
|
||
|
- PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "open");
|
||
|
- PyErr_Clear();
|
||
|
- if (obj && !PythonQtSlotFunction_Check(obj)) {
|
||
|
- static const char* argumentList[] ={"bool" , "QIODevice::OpenMode"};
|
||
|
- static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
||
|
- bool returnValue;
|
||
|
- void* args[2] = {NULL, (void*)&mode};
|
||
|
- PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
||
|
- if (result) {
|
||
|
- args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
||
|
- if (args[0]!=&returnValue) {
|
||
|
- if (args[0]==NULL) {
|
||
|
- PythonQt::priv()->handleVirtualOverloadReturnError("open", methodInfo, result);
|
||
|
- } else {
|
||
|
- returnValue = *((bool*)args[0]);
|
||
|
- }
|
||
|
- }
|
||
|
- }
|
||
|
- if (result) { Py_DECREF(result); }
|
||
|
- Py_DECREF(obj);
|
||
|
- return returnValue;
|
||
|
- }
|
||
|
-}
|
||
|
- return QUdpSocket::open(mode);
|
||
|
-}
|
||
|
-bool PythonQtShell_QUdpSocket::seek(qint64 pos)
|
||
|
-{
|
||
|
-if (_wrapper) {
|
||
|
- PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "seek");
|
||
|
- PyErr_Clear();
|
||
|
- if (obj && !PythonQtSlotFunction_Check(obj)) {
|
||
|
- static const char* argumentList[] ={"bool" , "qint64"};
|
||
|
- static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
||
|
- bool returnValue;
|
||
|
- void* args[2] = {NULL, (void*)&pos};
|
||
|
- PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
||
|
- if (result) {
|
||
|
- args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
|
||
|
- if (args[0]!=&returnValue) {
|
||
|
- if (args[0]==NULL) {
|
||
|
- PythonQt::priv()->handleVirtualOverloadReturnError("seek", methodInfo, result);
|
||
|
- } else {
|
||
|
- returnValue = *((bool*)args[0]);
|
||
|
- }
|
||
|
- }
|
||
|
- }
|
||
|
- if (result) { Py_DECREF(result); }
|
||
|
- Py_DECREF(obj);
|
||
|
- return returnValue;
|
||
|
- }
|
||
|
-}
|
||
|
- return QUdpSocket::seek(pos);
|
||
|
-}
|
||
|
-void PythonQtShell_QUdpSocket::childEvent(QChildEvent* arg__1)
|
||
|
-{
|
||
|
-if (_wrapper) {
|
||
|
- PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "childEvent");
|
||
|
- PyErr_Clear();
|
||
|
- if (obj && !PythonQtSlotFunction_Check(obj)) {
|
||
|
- static const char* argumentList[] ={"" , "QChildEvent*"};
|
||
|
- static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
||
|
- void* args[2] = {NULL, (void*)&arg__1};
|
||
|
- PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
||
|
- if (result) { Py_DECREF(result); }
|
||
|
- Py_DECREF(obj);
|
||
|
- return;
|
||
|
- }
|
||
|
-}
|
||
|
- QUdpSocket::childEvent(arg__1);
|
||
|
-}
|
||
|
-void PythonQtShell_QUdpSocket::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);
|
||
|
-}
|
||
|
-void PythonQtShell_QUdpSocket::customEvent(QEvent* arg__1)
|
||
|
-{
|
||
|
-if (_wrapper) {
|
||
|
- PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, "customEvent");
|
||
|
- PyErr_Clear();
|
||
|
- if (obj && !PythonQtSlotFunction_Check(obj)) {
|
||
|
- static const char* argumentList[] ={"" , "QEvent*"};
|
||
|
- static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
|
||
|
- void* args[2] = {NULL, (void*)&arg__1};
|
||
|
- PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
|
||
|
- if (result) { Py_DECREF(result); }
|
||
|
- Py_DECREF(obj);
|
||
|
- return;
|
||
|
- }
|
||
|
-}
|
||
|
- QUdpSocket::customEvent(arg__1);
|
||
|
-}
|
||
|
-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));
|
||
|
-}
|
||
|
-
|
||
|
-bool PythonQtWrapper_QUrlInfo::static_QUrlInfo_equal(const QUrlInfo& i1, const QUrlInfo& i2, int sortBy)
|
||
|
-{
|
||
|
- return (QUrlInfo::equal(i1, i2, sortBy));
|
||
|
-}
|
||
|
-
|
||
|
-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());
|
||
|
-}
|
||
|
-
|
||
|
-QString PythonQtWrapper_QUrlInfo::name(QUrlInfo* theWrappedObject) const
|
||
|
-{
|
||
|
- return ( theWrappedObject->name());
|
||
|
-}
|
||
|
-
|
||
|
-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));
|
||
|
-}
|
||
|
-
|
||
|
-
|
||
|
diff --git a/3rdparty/pythonqt/generated_cpp/com_trolltech_qt_network/com_trolltech_qt_network1.h b/3rdparty/pythonqt/generated_cpp/com_trolltech_qt_network/com_trolltech_qt_network1.h
|
||
|
index 923fd89..d5ca517 100644
|
||
|
--- a/3rdparty/pythonqt/generated_cpp/com_trolltech_qt_network/com_trolltech_qt_network1.h
|
||
|
+++ b/3rdparty/pythonqt/generated_cpp/com_trolltech_qt_network/com_trolltech_qt_network1.h
|
||
|
@@ -16,11 +16,7 @@
|
||
|
#include <qsslerror.h>
|
||
|
#include <qsslkey.h>
|
||
|
#include <qsslsocket.h>
|
||
|
-#include <qtcpserver.h>
|
||
|
-#include <qtcpsocket.h>
|
||
|
-#include <qudpsocket.h>
|
||
|
#include <qurl.h>
|
||
|
-#include <qurlinfo.h>
|
||
|
|
||
|
|
||
|
|
||
|
@@ -170,237 +166,3 @@ void delete_QSslSocket(QSslSocket* obj) { delete obj; }
|
||
|
|
||
|
|
||
|
|
||
|
-
|
||
|
-class PythonQtShell_QTcpServer : public QTcpServer
|
||
|
-{
|
||
|
-public:
|
||
|
- PythonQtShell_QTcpServer(QObject* parent = 0):QTcpServer(parent),_wrapper(NULL) {};
|
||
|
-
|
||
|
-virtual QTcpSocket* nextPendingConnection();
|
||
|
-virtual bool hasPendingConnections() const;
|
||
|
-virtual void incomingConnection(int handle);
|
||
|
-virtual void childEvent(QChildEvent* arg__1);
|
||
|
-virtual void timerEvent(QTimerEvent* arg__1);
|
||
|
-virtual void customEvent(QEvent* arg__1);
|
||
|
-virtual bool event(QEvent* arg__1);
|
||
|
-virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
|
||
|
-
|
||
|
- PythonQtInstanceWrapper* _wrapper;
|
||
|
-};
|
||
|
-
|
||
|
-class PythonQtPublicPromoter_QTcpServer : public QTcpServer
|
||
|
-{ public:
|
||
|
-inline QTcpSocket* promoted_nextPendingConnection() { return QTcpServer::nextPendingConnection(); }
|
||
|
-inline bool promoted_hasPendingConnections() const { return QTcpServer::hasPendingConnections(); }
|
||
|
-inline void promoted_incomingConnection(int handle) { QTcpServer::incomingConnection(handle); }
|
||
|
-};
|
||
|
-
|
||
|
-class PythonQtWrapper_QTcpServer : public QObject
|
||
|
-{ Q_OBJECT
|
||
|
-public:
|
||
|
-public slots:
|
||
|
-QTcpServer* new_QTcpServer(QObject* parent = 0);
|
||
|
-void delete_QTcpServer(QTcpServer* obj) { delete obj; }
|
||
|
- int maxPendingConnections(QTcpServer* theWrappedObject) const;
|
||
|
- QAbstractSocket::SocketError serverError(QTcpServer* theWrappedObject) const;
|
||
|
- bool waitForNewConnection(QTcpServer* theWrappedObject, int msec = 0, bool* timedOut = 0);
|
||
|
- bool isListening(QTcpServer* theWrappedObject) const;
|
||
|
- unsigned short serverPort(QTcpServer* theWrappedObject) const;
|
||
|
- QTcpSocket* nextPendingConnection(QTcpServer* theWrappedObject);
|
||
|
- void close(QTcpServer* theWrappedObject);
|
||
|
- void setProxy(QTcpServer* theWrappedObject, const QNetworkProxy& networkProxy);
|
||
|
- QNetworkProxy proxy(QTcpServer* theWrappedObject) const;
|
||
|
- QHostAddress serverAddress(QTcpServer* theWrappedObject) const;
|
||
|
- int socketDescriptor(QTcpServer* theWrappedObject) const;
|
||
|
- bool setSocketDescriptor(QTcpServer* theWrappedObject, int socketDescriptor);
|
||
|
- void setMaxPendingConnections(QTcpServer* theWrappedObject, int numConnections);
|
||
|
- bool listen(QTcpServer* theWrappedObject, const QHostAddress& address = QHostAddress::Any, unsigned short port = 0);
|
||
|
- bool hasPendingConnections(QTcpServer* theWrappedObject) const;
|
||
|
- QString errorString(QTcpServer* theWrappedObject) const;
|
||
|
- void incomingConnection(QTcpServer* theWrappedObject, int handle);
|
||
|
-};
|
||
|
-
|
||
|
-
|
||
|
-
|
||
|
-
|
||
|
-
|
||
|
-class PythonQtShell_QTcpSocket : public QTcpSocket
|
||
|
-{
|
||
|
-public:
|
||
|
- PythonQtShell_QTcpSocket(QObject* parent = 0):QTcpSocket(parent),_wrapper(NULL) {};
|
||
|
-
|
||
|
-virtual qint64 bytesAvailable() const;
|
||
|
-virtual bool waitForBytesWritten(int msecs);
|
||
|
-virtual bool isSequential() const;
|
||
|
-virtual qint64 readData(char* data, qint64 maxlen);
|
||
|
-virtual bool reset();
|
||
|
-virtual qint64 bytesToWrite() const;
|
||
|
-virtual bool waitForReadyRead(int msecs);
|
||
|
-virtual qint64 writeData(const char* data, qint64 len);
|
||
|
-virtual bool canReadLine() const;
|
||
|
-virtual void close();
|
||
|
-virtual bool atEnd() const;
|
||
|
-virtual qint64 readLineData(char* data, qint64 maxlen);
|
||
|
-virtual qint64 size() const;
|
||
|
-virtual qint64 pos() const;
|
||
|
-virtual bool open(QIODevice::OpenMode mode);
|
||
|
-virtual bool seek(qint64 pos);
|
||
|
-virtual void childEvent(QChildEvent* arg__1);
|
||
|
-virtual void timerEvent(QTimerEvent* arg__1);
|
||
|
-virtual void customEvent(QEvent* arg__1);
|
||
|
-virtual bool event(QEvent* arg__1);
|
||
|
-virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
|
||
|
-
|
||
|
- PythonQtInstanceWrapper* _wrapper;
|
||
|
-};
|
||
|
-
|
||
|
-class PythonQtWrapper_QTcpSocket : public QObject
|
||
|
-{ Q_OBJECT
|
||
|
-public:
|
||
|
-public slots:
|
||
|
-QTcpSocket* new_QTcpSocket(QObject* parent = 0);
|
||
|
-void delete_QTcpSocket(QTcpSocket* obj) { delete obj; }
|
||
|
-};
|
||
|
-
|
||
|
-
|
||
|
-
|
||
|
-
|
||
|
-
|
||
|
-class PythonQtShell_QUdpSocket : public QUdpSocket
|
||
|
-{
|
||
|
-public:
|
||
|
- PythonQtShell_QUdpSocket(QObject* parent = 0):QUdpSocket(parent),_wrapper(NULL) {};
|
||
|
-
|
||
|
-virtual qint64 bytesAvailable() const;
|
||
|
-virtual bool waitForBytesWritten(int msecs);
|
||
|
-virtual qint64 size() const;
|
||
|
-virtual bool isSequential() const;
|
||
|
-virtual qint64 readData(char* data, qint64 maxlen);
|
||
|
-virtual qint64 bytesToWrite() const;
|
||
|
-virtual bool waitForReadyRead(int msecs);
|
||
|
-virtual qint64 writeData(const char* data, qint64 len);
|
||
|
-virtual bool canReadLine() const;
|
||
|
-virtual void close();
|
||
|
-virtual bool atEnd() const;
|
||
|
-virtual qint64 readLineData(char* data, qint64 maxlen);
|
||
|
-virtual qint64 pos() const;
|
||
|
-virtual bool reset();
|
||
|
-virtual bool open(QIODevice::OpenMode mode);
|
||
|
-virtual bool seek(qint64 pos);
|
||
|
-virtual void childEvent(QChildEvent* arg__1);
|
||
|
-virtual void timerEvent(QTimerEvent* arg__1);
|
||
|
-virtual void customEvent(QEvent* arg__1);
|
||
|
-virtual bool event(QEvent* arg__1);
|
||
|
-virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
|
||
|
-
|
||
|
- PythonQtInstanceWrapper* _wrapper;
|
||
|
-};
|
||
|
-
|
||
|
-class PythonQtWrapper_QUdpSocket : public QObject
|
||
|
-{ Q_OBJECT
|
||
|
-public:
|
||
|
-Q_ENUMS(BindFlag )
|
||
|
-Q_FLAGS(BindMode )
|
||
|
-enum BindFlag{
|
||
|
- DefaultForPlatform = QUdpSocket::DefaultForPlatform, ShareAddress = QUdpSocket::ShareAddress, DontShareAddress = QUdpSocket::DontShareAddress, ReuseAddressHint = QUdpSocket::ReuseAddressHint};
|
||
|
-Q_DECLARE_FLAGS(BindMode, BindFlag)
|
||
|
-public slots:
|
||
|
-QUdpSocket* new_QUdpSocket(QObject* parent = 0);
|
||
|
-void delete_QUdpSocket(QUdpSocket* obj) { delete obj; }
|
||
|
- qint64 writeDatagram(QUdpSocket* theWrappedObject, const QByteArray& datagram, const QHostAddress& host, unsigned short port);
|
||
|
- bool bind(QUdpSocket* theWrappedObject, unsigned short port = 0);
|
||
|
- bool hasPendingDatagrams(QUdpSocket* theWrappedObject) const;
|
||
|
- qint64 pendingDatagramSize(QUdpSocket* theWrappedObject) const;
|
||
|
- bool bind(QUdpSocket* theWrappedObject, unsigned short port, QUdpSocket::BindMode mode);
|
||
|
- bool bind(QUdpSocket* theWrappedObject, const QHostAddress& address, unsigned short port, QUdpSocket::BindMode mode);
|
||
|
- bool bind(QUdpSocket* theWrappedObject, const QHostAddress& address, unsigned short port);
|
||
|
- qint64 readDatagram(QUdpSocket* theWrappedObject, char* data, qint64 maxlen, QHostAddress* host = 0, unsigned short* port = 0);
|
||
|
-};
|
||
|
-
|
||
|
-
|
||
|
-
|
||
|
-
|
||
|
-
|
||
|
-class PythonQtShell_QUrlInfo : public QUrlInfo
|
||
|
-{
|
||
|
-public:
|
||
|
- PythonQtShell_QUrlInfo():QUrlInfo(),_wrapper(NULL) {};
|
||
|
- PythonQtShell_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):QUrlInfo(name, permissions, owner, group, size, lastModified, lastRead, isDir, isFile, isSymLink, isWritable, isReadable, isExecutable),_wrapper(NULL) {};
|
||
|
- PythonQtShell_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):QUrlInfo(url, permissions, owner, group, size, lastModified, lastRead, isDir, isFile, isSymLink, isWritable, isReadable, isExecutable),_wrapper(NULL) {};
|
||
|
- PythonQtShell_QUrlInfo(const QUrlInfo& ui):QUrlInfo(ui),_wrapper(NULL) {};
|
||
|
-
|
||
|
-virtual void setWritable(bool b);
|
||
|
-virtual void setName(const QString& name);
|
||
|
-virtual void setReadable(bool b);
|
||
|
-virtual void setGroup(const QString& s);
|
||
|
-virtual void setSize(qint64 size);
|
||
|
-virtual void setFile(bool b);
|
||
|
-virtual void setLastModified(const QDateTime& dt);
|
||
|
-virtual void setDir(bool b);
|
||
|
-virtual void setPermissions(int p);
|
||
|
-virtual void setOwner(const QString& s);
|
||
|
-virtual void setSymLink(bool b);
|
||
|
-
|
||
|
- PythonQtInstanceWrapper* _wrapper;
|
||
|
-};
|
||
|
-
|
||
|
-class PythonQtPublicPromoter_QUrlInfo : public QUrlInfo
|
||
|
-{ public:
|
||
|
-inline void promoted_setWritable(bool b) { QUrlInfo::setWritable(b); }
|
||
|
-inline void promoted_setName(const QString& name) { QUrlInfo::setName(name); }
|
||
|
-inline void promoted_setReadable(bool b) { QUrlInfo::setReadable(b); }
|
||
|
-inline void promoted_setGroup(const QString& s) { QUrlInfo::setGroup(s); }
|
||
|
-inline void promoted_setSize(qint64 size) { QUrlInfo::setSize(size); }
|
||
|
-inline void promoted_setFile(bool b) { QUrlInfo::setFile(b); }
|
||
|
-inline void promoted_setLastModified(const QDateTime& dt) { QUrlInfo::setLastModified(dt); }
|
||
|
-inline void promoted_setDir(bool b) { QUrlInfo::setDir(b); }
|
||
|
-inline void promoted_setPermissions(int p) { QUrlInfo::setPermissions(p); }
|
||
|
-inline void promoted_setOwner(const QString& s) { QUrlInfo::setOwner(s); }
|
||
|
-inline void promoted_setSymLink(bool b) { QUrlInfo::setSymLink(b); }
|
||
|
-};
|
||
|
-
|
||
|
-class PythonQtWrapper_QUrlInfo : public QObject
|
||
|
-{ Q_OBJECT
|
||
|
-public:
|
||
|
-Q_ENUMS(PermissionSpec )
|
||
|
-enum PermissionSpec{
|
||
|
- ReadOwner = QUrlInfo::ReadOwner, WriteOwner = QUrlInfo::WriteOwner, ExeOwner = QUrlInfo::ExeOwner, ReadGroup = QUrlInfo::ReadGroup, WriteGroup = QUrlInfo::WriteGroup, ExeGroup = QUrlInfo::ExeGroup, ReadOther = QUrlInfo::ReadOther, WriteOther = QUrlInfo::WriteOther, ExeOther = QUrlInfo::ExeOther};
|
||
|
-public slots:
|
||
|
-QUrlInfo* new_QUrlInfo();
|
||
|
-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);
|
||
|
-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);
|
||
|
-QUrlInfo* new_QUrlInfo(const QUrlInfo& ui);
|
||
|
-void delete_QUrlInfo(QUrlInfo* obj) { delete obj; }
|
||
|
- bool isValid(QUrlInfo* theWrappedObject) const;
|
||
|
- bool isWritable(QUrlInfo* theWrappedObject) const;
|
||
|
- void setWritable(QUrlInfo* theWrappedObject, bool b);
|
||
|
- bool static_QUrlInfo_equal(const QUrlInfo& i1, const QUrlInfo& i2, int sortBy);
|
||
|
- void setName(QUrlInfo* theWrappedObject, const QString& name);
|
||
|
- void setReadable(QUrlInfo* theWrappedObject, bool b);
|
||
|
- bool isDir(QUrlInfo* theWrappedObject) const;
|
||
|
- QString name(QUrlInfo* theWrappedObject) const;
|
||
|
- void setLastRead(QUrlInfo* theWrappedObject, const QDateTime& dt);
|
||
|
- void setGroup(QUrlInfo* theWrappedObject, const QString& s);
|
||
|
- bool isExecutable(QUrlInfo* theWrappedObject) const;
|
||
|
- QDateTime lastModified(QUrlInfo* theWrappedObject) const;
|
||
|
- bool static_QUrlInfo_greaterThan(const QUrlInfo& i1, const QUrlInfo& i2, int sortBy);
|
||
|
- void setSize(QUrlInfo* theWrappedObject, qint64 size);
|
||
|
- QString owner(QUrlInfo* theWrappedObject) const;
|
||
|
- bool operator_equal(QUrlInfo* theWrappedObject, const QUrlInfo& i) const;
|
||
|
- void setFile(QUrlInfo* theWrappedObject, bool b);
|
||
|
- bool isSymLink(QUrlInfo* theWrappedObject) const;
|
||
|
- void setLastModified(QUrlInfo* theWrappedObject, const QDateTime& dt);
|
||
|
- void setDir(QUrlInfo* theWrappedObject, bool b);
|
||
|
- void setPermissions(QUrlInfo* theWrappedObject, int p);
|
||
|
- bool isFile(QUrlInfo* theWrappedObject) const;
|
||
|
- bool isReadable(QUrlInfo* theWrappedObject) const;
|
||
|
- void setOwner(QUrlInfo* theWrappedObject, const QString& s);
|
||
|
- QString group(QUrlInfo* theWrappedObject) const;
|
||
|
- qint64 size(QUrlInfo* theWrappedObject) const;
|
||
|
- bool static_QUrlInfo_lessThan(const QUrlInfo& i1, const QUrlInfo& i2, int sortBy);
|
||
|
- QDateTime lastRead(QUrlInfo* theWrappedObject) const;
|
||
|
- int permissions(QUrlInfo* theWrappedObject) const;
|
||
|
- void setSymLink(QUrlInfo* theWrappedObject, bool b);
|
||
|
-};
|
||
|
-
|
||
|
-
|