com_trolltech_qt_network0.h
1385 lines
| 68.8 KiB
| text/x-c
|
CLexer
florianlink
|
r99 | #include <PythonQt.h> | ||
| #include <QDateTime> | ||||
| #include <QObject> | ||||
| #include <QVariant> | ||||
|
florianlink
|
r110 | #include <qabstractnetworkcache.h> | ||
|
florianlink
|
r99 | #include <qabstractsocket.h> | ||
| #include <qauthenticator.h> | ||||
| #include <qbytearray.h> | ||||
| #include <qcoreevent.h> | ||||
| #include <qdatastream.h> | ||||
| #include <qdatetime.h> | ||||
| #include <qftp.h> | ||||
| #include <qhostaddress.h> | ||||
| #include <qhostinfo.h> | ||||
| #include <qhttp.h> | ||||
|
florianlink
|
r186 | #include <qhttpmultipart.h> | ||
|
florianlink
|
r99 | #include <qiodevice.h> | ||
| #include <qlist.h> | ||||
| #include <qlocalserver.h> | ||||
| #include <qlocalsocket.h> | ||||
| #include <qnetworkaccessmanager.h> | ||||
| #include <qnetworkcookie.h> | ||||
|
florianlink
|
r110 | #include <qnetworkcookiejar.h> | ||
| #include <qnetworkdiskcache.h> | ||||
|
florianlink
|
r99 | #include <qnetworkinterface.h> | ||
| #include <qnetworkproxy.h> | ||||
| #include <qnetworkreply.h> | ||||
| #include <qnetworkrequest.h> | ||||
| #include <qobject.h> | ||||
| #include <qpair.h> | ||||
| #include <qssl.h> | ||||
| #include <qstringlist.h> | ||||
|
florianlink
|
r120 | #include <qtcpserver.h> | ||
|
florianlink
|
r99 | #include <qtcpsocket.h> | ||
| #include <qurl.h> | ||||
| #include <qurlinfo.h> | ||||
|
florianlink
|
r110 | class PythonQtShell_QAbstractNetworkCache : public QAbstractNetworkCache | ||
| { | ||||
| public: | ||||
| PythonQtShell_QAbstractNetworkCache(QObject* parent = 0):QAbstractNetworkCache(parent),_wrapper(NULL) {}; | ||||
|
florianlink
|
r186 | ~PythonQtShell_QAbstractNetworkCache(); | ||
|
florianlink
|
r110 | virtual qint64 cacheSize() const; | ||
|
florianlink
|
r128 | virtual void childEvent(QChildEvent* arg__1); | ||
| virtual void clear(); | ||||
| virtual void customEvent(QEvent* arg__1); | ||||
|
florianlink
|
r120 | virtual QIODevice* data(const QUrl& url); | ||
|
florianlink
|
r117 | virtual bool event(QEvent* arg__1); | ||
|
florianlink
|
r110 | virtual bool eventFilter(QObject* arg__1, QEvent* arg__2); | ||
|
florianlink
|
r128 | virtual void insert(QIODevice* device); | ||
| virtual QNetworkCacheMetaData metaData(const QUrl& url); | ||||
| virtual QIODevice* prepare(const QNetworkCacheMetaData& metaData); | ||||
| virtual bool remove(const QUrl& url); | ||||
|
florianlink
|
r120 | virtual void timerEvent(QTimerEvent* arg__1); | ||
|
florianlink
|
r128 | virtual void updateMetaData(const QNetworkCacheMetaData& metaData); | ||
|
florianlink
|
r110 | |||
| PythonQtInstanceWrapper* _wrapper; | ||||
| }; | ||||
| class PythonQtWrapper_QAbstractNetworkCache : public QObject | ||||
| { Q_OBJECT | ||||
| public: | ||||
| public slots: | ||||
| void delete_QAbstractNetworkCache(QAbstractNetworkCache* obj) { delete obj; } | ||||
| }; | ||||
|
florianlink
|
r99 | class PythonQtShell_QAbstractSocket : public QAbstractSocket | ||
| { | ||||
| public: | ||||
| PythonQtShell_QAbstractSocket(QAbstractSocket::SocketType socketType, QObject* parent):QAbstractSocket(socketType, parent),_wrapper(NULL) {}; | ||||
|
florianlink
|
r186 | ~PythonQtShell_QAbstractSocket(); | ||
|
florianlink
|
r128 | virtual bool atEnd() const; | ||
|
florianlink
|
r120 | virtual qint64 bytesAvailable() const; | ||
|
florianlink
|
r128 | virtual qint64 bytesToWrite() const; | ||
|
florianlink
|
r99 | virtual bool canReadLine() const; | ||
|
florianlink
|
r128 | virtual void childEvent(QChildEvent* arg__1); | ||
|
florianlink
|
r99 | virtual void close(); | ||
|
florianlink
|
r128 | virtual void customEvent(QEvent* arg__1); | ||
| virtual bool event(QEvent* arg__1); | ||||
| virtual bool eventFilter(QObject* arg__1, QEvent* arg__2); | ||||
| virtual bool isSequential() const; | ||||
| virtual bool open(QIODevice::OpenMode mode); | ||||
| virtual qint64 pos() const; | ||||
|
florianlink
|
r120 | virtual qint64 readData(char* data, qint64 maxlen); | ||
|
florianlink
|
r128 | virtual qint64 readLineData(char* data, qint64 maxlen); | ||
|
florianlink
|
r99 | virtual bool reset(); | ||
|
florianlink
|
r110 | virtual bool seek(qint64 pos); | ||
|
florianlink
|
r120 | virtual qint64 size() const; | ||
| virtual void timerEvent(QTimerEvent* arg__1); | ||||
|
florianlink
|
r128 | virtual bool waitForBytesWritten(int msecs = 30000); | ||
| virtual bool waitForReadyRead(int msecs = 30000); | ||||
| virtual qint64 writeData(const char* data, qint64 len); | ||||
|
florianlink
|
r99 | |||
| PythonQtInstanceWrapper* _wrapper; | ||||
| }; | ||||
| class PythonQtPublicPromoter_QAbstractSocket : public QAbstractSocket | ||||
| { public: | ||||
|
florianlink
|
r128 | inline bool promoted_atEnd() const { return QAbstractSocket::atEnd(); } | ||
|
florianlink
|
r120 | inline qint64 promoted_bytesAvailable() const { return QAbstractSocket::bytesAvailable(); } | ||
|
florianlink
|
r128 | inline qint64 promoted_bytesToWrite() const { return QAbstractSocket::bytesToWrite(); } | ||
|
florianlink
|
r99 | inline bool promoted_canReadLine() const { return QAbstractSocket::canReadLine(); } | ||
|
florianlink
|
r128 | inline void promoted_close() { QAbstractSocket::close(); } | ||
| inline bool promoted_isSequential() const { return QAbstractSocket::isSequential(); } | ||||
| inline qint64 promoted_readData(char* data, qint64 maxlen) { return QAbstractSocket::readData(data, maxlen); } | ||||
|
florianlink
|
r99 | inline qint64 promoted_readLineData(char* data, qint64 maxlen) { return QAbstractSocket::readLineData(data, maxlen); } | ||
|
florianlink
|
r128 | inline bool promoted_waitForBytesWritten(int msecs = 30000) { return QAbstractSocket::waitForBytesWritten(msecs); } | ||
|
florianlink
|
r99 | inline bool promoted_waitForReadyRead(int msecs = 30000) { return QAbstractSocket::waitForReadyRead(msecs); } | ||
| inline qint64 promoted_writeData(const char* data, qint64 len) { return QAbstractSocket::writeData(data, len); } | ||||
| }; | ||||
| class PythonQtWrapper_QAbstractSocket : public QObject | ||||
| { Q_OBJECT | ||||
| public: | ||||
| public slots: | ||||
| QAbstractSocket* new_QAbstractSocket(QAbstractSocket::SocketType socketType, QObject* parent); | ||||
| void delete_QAbstractSocket(QAbstractSocket* obj) { delete obj; } | ||||
|
florianlink
|
r128 | void abort(QAbstractSocket* theWrappedObject); | ||
| bool atEnd(QAbstractSocket* theWrappedObject) const; | ||||
|
florianlink
|
r99 | qint64 bytesAvailable(QAbstractSocket* theWrappedObject) const; | ||
|
florianlink
|
r128 | qint64 bytesToWrite(QAbstractSocket* theWrappedObject) const; | ||
| bool canReadLine(QAbstractSocket* theWrappedObject) const; | ||||
| void close(QAbstractSocket* theWrappedObject); | ||||
| void connectToHost(QAbstractSocket* theWrappedObject, const QHostAddress& address, unsigned short port, QIODevice::OpenMode mode = QIODevice::ReadWrite); | ||||
| void connectToHost(QAbstractSocket* theWrappedObject, const QString& hostName, unsigned short port, QIODevice::OpenMode mode = QIODevice::ReadWrite); | ||||
| void disconnectFromHost(QAbstractSocket* theWrappedObject); | ||||
|
florianlink
|
r110 | QAbstractSocket::SocketError error(QAbstractSocket* theWrappedObject) const; | ||
|
florianlink
|
r128 | bool flush(QAbstractSocket* theWrappedObject); | ||
| bool isSequential(QAbstractSocket* theWrappedObject) const; | ||||
| bool isValid(QAbstractSocket* theWrappedObject) const; | ||||
| QHostAddress localAddress(QAbstractSocket* theWrappedObject) const; | ||||
|
florianlink
|
r120 | unsigned short localPort(QAbstractSocket* theWrappedObject) const; | ||
|
florianlink
|
r128 | QHostAddress peerAddress(QAbstractSocket* theWrappedObject) const; | ||
| QString peerName(QAbstractSocket* theWrappedObject) const; | ||||
| unsigned short peerPort(QAbstractSocket* theWrappedObject) const; | ||||
| QNetworkProxy proxy(QAbstractSocket* theWrappedObject) const; | ||||
| qint64 readBufferSize(QAbstractSocket* theWrappedObject) const; | ||||
| qint64 readData(QAbstractSocket* theWrappedObject, char* data, qint64 maxlen); | ||||
|
florianlink
|
r120 | qint64 readLineData(QAbstractSocket* theWrappedObject, char* data, qint64 maxlen); | ||
|
florianlink
|
r128 | void setProxy(QAbstractSocket* theWrappedObject, const QNetworkProxy& networkProxy); | ||
|
florianlink
|
r99 | void setReadBufferSize(QAbstractSocket* theWrappedObject, qint64 size); | ||
|
florianlink
|
r120 | bool setSocketDescriptor(QAbstractSocket* theWrappedObject, int socketDescriptor, QAbstractSocket::SocketState state = QAbstractSocket::ConnectedState, QIODevice::OpenMode openMode = QIODevice::ReadWrite); | ||
|
florianlink
|
r128 | int socketDescriptor(QAbstractSocket* theWrappedObject) const; | ||
|
florianlink
|
r120 | QAbstractSocket::SocketType socketType(QAbstractSocket* theWrappedObject) const; | ||
|
florianlink
|
r128 | QAbstractSocket::SocketState state(QAbstractSocket* theWrappedObject) const; | ||
| bool waitForBytesWritten(QAbstractSocket* theWrappedObject, int msecs = 30000); | ||||
|
florianlink
|
r110 | bool waitForConnected(QAbstractSocket* theWrappedObject, int msecs = 30000); | ||
|
florianlink
|
r128 | bool waitForDisconnected(QAbstractSocket* theWrappedObject, int msecs = 30000); | ||
| bool waitForReadyRead(QAbstractSocket* theWrappedObject, int msecs = 30000); | ||||
| qint64 writeData(QAbstractSocket* theWrappedObject, const char* data, qint64 len); | ||||
|
florianlink
|
r99 | }; | ||
| class PythonQtWrapper_QAuthenticator : public QObject | ||||
| { Q_OBJECT | ||||
| public: | ||||
| public slots: | ||||
| QAuthenticator* new_QAuthenticator(); | ||||
| QAuthenticator* new_QAuthenticator(const QAuthenticator& other); | ||||
| void delete_QAuthenticator(QAuthenticator* obj) { delete obj; } | ||||
|
florianlink
|
r128 | bool isNull(QAuthenticator* theWrappedObject) const; | ||
|
florianlink
|
r120 | bool __ne__(QAuthenticator* theWrappedObject, const QAuthenticator& other) const; | ||
| bool __eq__(QAuthenticator* theWrappedObject, const QAuthenticator& other) const; | ||||
|
florianlink
|
r186 | QVariant option(QAuthenticator* theWrappedObject, const QString& opt) const; | ||
| QHash<QString , QVariant > options(QAuthenticator* theWrappedObject) const; | ||||
|
florianlink
|
r128 | QString password(QAuthenticator* theWrappedObject) const; | ||
| QString realm(QAuthenticator* theWrappedObject) const; | ||||
|
florianlink
|
r186 | void setOption(QAuthenticator* theWrappedObject, const QString& opt, const QVariant& value); | ||
|
florianlink
|
r128 | void setPassword(QAuthenticator* theWrappedObject, const QString& password); | ||
| void setUser(QAuthenticator* theWrappedObject, const QString& user); | ||||
|
florianlink
|
r117 | QString user(QAuthenticator* theWrappedObject) const; | ||
|
florianlink
|
r120 | bool __nonzero__(QAuthenticator* obj) { return !obj->isNull(); } | ||
|
florianlink
|
r99 | }; | ||
| class PythonQtShell_QFtp : public QFtp | ||||
| { | ||||
| public: | ||||
| PythonQtShell_QFtp(QObject* parent = 0):QFtp(parent),_wrapper(NULL) {}; | ||||
|
florianlink
|
r186 | ~PythonQtShell_QFtp(); | ||
|
florianlink
|
r120 | virtual void childEvent(QChildEvent* arg__1); | ||
| virtual void customEvent(QEvent* arg__1); | ||||
|
florianlink
|
r128 | virtual bool event(QEvent* arg__1); | ||
| virtual bool eventFilter(QObject* arg__1, QEvent* arg__2); | ||||
|
florianlink
|
r120 | virtual void timerEvent(QTimerEvent* arg__1); | ||
|
florianlink
|
r99 | |||
| PythonQtInstanceWrapper* _wrapper; | ||||
| }; | ||||
| class PythonQtWrapper_QFtp : public QObject | ||||
| { Q_OBJECT | ||||
| public: | ||||
| Q_ENUMS(TransferType Error Command TransferMode State ) | ||||
| enum TransferType{ | ||||
| Binary = QFtp::Binary, Ascii = QFtp::Ascii}; | ||||
| enum Error{ | ||||
| NoError = QFtp::NoError, UnknownError = QFtp::UnknownError, HostNotFound = QFtp::HostNotFound, ConnectionRefused = QFtp::ConnectionRefused, NotConnected = QFtp::NotConnected}; | ||||
| enum Command{ | ||||
| None = QFtp::None, SetTransferMode = QFtp::SetTransferMode, SetProxy = QFtp::SetProxy, ConnectToHost = QFtp::ConnectToHost, Login = QFtp::Login, Close = QFtp::Close, List = QFtp::List, Cd = QFtp::Cd, Get = QFtp::Get, Put = QFtp::Put, Remove = QFtp::Remove, Mkdir = QFtp::Mkdir, Rmdir = QFtp::Rmdir, Rename = QFtp::Rename, RawCommand = QFtp::RawCommand}; | ||||
| enum TransferMode{ | ||||
| Active = QFtp::Active, Passive = QFtp::Passive}; | ||||
| enum State{ | ||||
| Unconnected = QFtp::Unconnected, HostLookup = QFtp::HostLookup, Connecting = QFtp::Connecting, Connected = QFtp::Connected, LoggedIn = QFtp::LoggedIn, Closing = QFtp::Closing}; | ||||
| public slots: | ||||
| QFtp* new_QFtp(QObject* parent = 0); | ||||
| void delete_QFtp(QFtp* obj) { delete obj; } | ||||
| qint64 bytesAvailable(QFtp* theWrappedObject) const; | ||||
|
florianlink
|
r128 | int cd(QFtp* theWrappedObject, const QString& dir); | ||
| void clearPendingCommands(QFtp* theWrappedObject); | ||||
| int close(QFtp* theWrappedObject); | ||||
| int connectToHost(QFtp* theWrappedObject, const QString& host, unsigned short port = 21); | ||||
|
florianlink
|
r120 | QFtp::Command currentCommand(QFtp* theWrappedObject) const; | ||
|
florianlink
|
r128 | QIODevice* currentDevice(QFtp* theWrappedObject) const; | ||
|
florianlink
|
r120 | int currentId(QFtp* theWrappedObject) const; | ||
|
florianlink
|
r128 | QFtp::Error error(QFtp* theWrappedObject) const; | ||
| QString errorString(QFtp* theWrappedObject) const; | ||||
|
florianlink
|
r99 | int get(QFtp* theWrappedObject, const QString& file, QIODevice* dev = 0, QFtp::TransferType type = QFtp::Binary); | ||
|
florianlink
|
r110 | bool hasPendingCommands(QFtp* theWrappedObject) const; | ||
|
florianlink
|
r128 | int list(QFtp* theWrappedObject, const QString& dir = QString()); | ||
| int login(QFtp* theWrappedObject, const QString& user = QString(), const QString& password = QString()); | ||||
|
florianlink
|
r99 | int mkdir(QFtp* theWrappedObject, const QString& dir); | ||
|
florianlink
|
r110 | int put(QFtp* theWrappedObject, QIODevice* dev, const QString& file, QFtp::TransferType type = QFtp::Binary); | ||
|
florianlink
|
r128 | int put(QFtp* theWrappedObject, const QByteArray& data, const QString& file, QFtp::TransferType type = QFtp::Binary); | ||
| int rawCommand(QFtp* theWrappedObject, const QString& command); | ||||
| qint64 read(QFtp* theWrappedObject, char* data, qint64 maxlen); | ||||
|
florianlink
|
r99 | QByteArray readAll(QFtp* theWrappedObject); | ||
|
florianlink
|
r120 | int remove(QFtp* theWrappedObject, const QString& file); | ||
|
florianlink
|
r128 | int rename(QFtp* theWrappedObject, const QString& oldname, const QString& newname); | ||
| int rmdir(QFtp* theWrappedObject, const QString& dir); | ||||
|
florianlink
|
r99 | int setProxy(QFtp* theWrappedObject, const QString& host, unsigned short port); | ||
|
florianlink
|
r128 | int setTransferMode(QFtp* theWrappedObject, QFtp::TransferMode mode); | ||
| QFtp::State state(QFtp* theWrappedObject) const; | ||||
|
florianlink
|
r99 | }; | ||
| class PythonQtWrapper_QHostAddress : public QObject | ||||
| { Q_OBJECT | ||||
| public: | ||||
| Q_ENUMS(SpecialAddress ) | ||||
| enum SpecialAddress{ | ||||
| Null = QHostAddress::Null, Broadcast = QHostAddress::Broadcast, LocalHost = QHostAddress::LocalHost, LocalHostIPv6 = QHostAddress::LocalHostIPv6, Any = QHostAddress::Any, AnyIPv6 = QHostAddress::AnyIPv6}; | ||||
| public slots: | ||||
| QHostAddress* new_QHostAddress(); | ||||
| QHostAddress* new_QHostAddress(QHostAddress::SpecialAddress address); | ||||
| QHostAddress* new_QHostAddress(const QHostAddress& copy); | ||||
| QHostAddress* new_QHostAddress(const QIPv6Address& ip6Addr); | ||||
| QHostAddress* new_QHostAddress(const QString& address); | ||||
| QHostAddress* new_QHostAddress(unsigned int ip4Addr); | ||||
| void delete_QHostAddress(QHostAddress* obj) { delete obj; } | ||||
|
florianlink
|
r128 | void clear(QHostAddress* theWrappedObject); | ||
| bool isInSubnet(QHostAddress* theWrappedObject, const QHostAddress& subnet, int netmask) const; | ||||
| bool isInSubnet(QHostAddress* theWrappedObject, const QPair<QHostAddress , int >& subnet) const; | ||||
| bool isNull(QHostAddress* theWrappedObject) const; | ||||
|
florianlink
|
r120 | bool __ne__(QHostAddress* theWrappedObject, QHostAddress::SpecialAddress address) const; | ||
|
florianlink
|
r128 | bool __ne__(QHostAddress* theWrappedObject, const QHostAddress& address) const; | ||
| void writeTo(QHostAddress* theWrappedObject, QDataStream& arg__1); | ||||
| bool __eq__(QHostAddress* theWrappedObject, QHostAddress::SpecialAddress address) const; | ||||
|
florianlink
|
r120 | bool __eq__(QHostAddress* theWrappedObject, const QHostAddress& address) const; | ||
|
florianlink
|
r128 | void readFrom(QHostAddress* theWrappedObject, QDataStream& arg__1); | ||
| QPair<QHostAddress , int > static_QHostAddress_parseSubnet(const QString& subnet); | ||||
| QAbstractSocket::NetworkLayerProtocol protocol(QHostAddress* theWrappedObject) const; | ||||
| QString scopeId(QHostAddress* theWrappedObject) const; | ||||
| void setAddress(QHostAddress* theWrappedObject, const QIPv6Address& ip6Addr); | ||||
|
florianlink
|
r120 | bool setAddress(QHostAddress* theWrappedObject, const QString& address); | ||
| void setAddress(QHostAddress* theWrappedObject, unsigned int ip4Addr); | ||||
|
florianlink
|
r99 | void setScopeId(QHostAddress* theWrappedObject, const QString& id); | ||
|
florianlink
|
r128 | unsigned int toIPv4Address(QHostAddress* theWrappedObject) const; | ||
| QIPv6Address toIPv6Address(QHostAddress* theWrappedObject) const; | ||||
| QString toString(QHostAddress* theWrappedObject) const; | ||||
|
florianlink
|
r117 | QString py_toString(QHostAddress*); | ||
|
florianlink
|
r120 | bool __nonzero__(QHostAddress* obj) { return !obj->isNull(); } | ||
|
florianlink
|
r99 | }; | ||
| class PythonQtWrapper_QHostInfo : public QObject | ||||
| { Q_OBJECT | ||||
| public: | ||||
| Q_ENUMS(HostInfoError ) | ||||
| enum HostInfoError{ | ||||
| NoError = QHostInfo::NoError, HostNotFound = QHostInfo::HostNotFound, UnknownError = QHostInfo::UnknownError}; | ||||
| public slots: | ||||
| QHostInfo* new_QHostInfo(const QHostInfo& d); | ||||
| QHostInfo* new_QHostInfo(int lookupId = -1); | ||||
| void delete_QHostInfo(QHostInfo* obj) { delete obj; } | ||||
|
florianlink
|
r120 | void static_QHostInfo_abortHostLookup(int lookupId); | ||
|
florianlink
|
r99 | QList<QHostAddress > addresses(QHostInfo* theWrappedObject) const; | ||
|
florianlink
|
r110 | QHostInfo::HostInfoError error(QHostInfo* theWrappedObject) const; | ||
|
florianlink
|
r99 | QString errorString(QHostInfo* theWrappedObject) const; | ||
|
florianlink
|
r128 | QHostInfo static_QHostInfo_fromName(const QString& name); | ||
| QString hostName(QHostInfo* theWrappedObject) const; | ||||
|
florianlink
|
r110 | QString static_QHostInfo_localDomainName(); | ||
|
florianlink
|
r128 | QString static_QHostInfo_localHostName(); | ||
| int static_QHostInfo_lookupHost(const QString& name, QObject* receiver, const char* member); | ||||
| int lookupId(QHostInfo* theWrappedObject) const; | ||||
| void setAddresses(QHostInfo* theWrappedObject, const QList<QHostAddress >& addresses); | ||||
| void setError(QHostInfo* theWrappedObject, QHostInfo::HostInfoError error); | ||||
| void setErrorString(QHostInfo* theWrappedObject, const QString& errorString); | ||||
| void setHostName(QHostInfo* theWrappedObject, const QString& name); | ||||
| void setLookupId(QHostInfo* theWrappedObject, int id); | ||||
|
florianlink
|
r99 | }; | ||
| class PythonQtShell_QHttp : public QHttp | ||||
| { | ||||
| public: | ||||
| PythonQtShell_QHttp(QObject* parent = 0):QHttp(parent),_wrapper(NULL) {}; | ||||
| PythonQtShell_QHttp(const QString& hostname, QHttp::ConnectionMode mode, unsigned short port = 0, QObject* parent = 0):QHttp(hostname, mode, port, parent),_wrapper(NULL) {}; | ||||
| PythonQtShell_QHttp(const QString& hostname, unsigned short port = 80, QObject* parent = 0):QHttp(hostname, port, parent),_wrapper(NULL) {}; | ||||
|
florianlink
|
r186 | ~PythonQtShell_QHttp(); | ||
|
florianlink
|
r120 | virtual void childEvent(QChildEvent* arg__1); | ||
| virtual void customEvent(QEvent* arg__1); | ||||
|
florianlink
|
r128 | virtual bool event(QEvent* arg__1); | ||
| virtual bool eventFilter(QObject* arg__1, QEvent* arg__2); | ||||
|
florianlink
|
r120 | virtual void timerEvent(QTimerEvent* arg__1); | ||
|
florianlink
|
r99 | |||
| PythonQtInstanceWrapper* _wrapper; | ||||
| }; | ||||
| class PythonQtWrapper_QHttp : public QObject | ||||
| { Q_OBJECT | ||||
| public: | ||||
| Q_ENUMS(Error ConnectionMode State ) | ||||
| enum Error{ | ||||
| NoError = QHttp::NoError, UnknownError = QHttp::UnknownError, HostNotFound = QHttp::HostNotFound, ConnectionRefused = QHttp::ConnectionRefused, UnexpectedClose = QHttp::UnexpectedClose, InvalidResponseHeader = QHttp::InvalidResponseHeader, WrongContentLength = QHttp::WrongContentLength, Aborted = QHttp::Aborted, AuthenticationRequiredError = QHttp::AuthenticationRequiredError, ProxyAuthenticationRequiredError = QHttp::ProxyAuthenticationRequiredError}; | ||||
| enum ConnectionMode{ | ||||
| ConnectionModeHttp = QHttp::ConnectionModeHttp, ConnectionModeHttps = QHttp::ConnectionModeHttps}; | ||||
| enum State{ | ||||
| Unconnected = QHttp::Unconnected, HostLookup = QHttp::HostLookup, Connecting = QHttp::Connecting, Sending = QHttp::Sending, Reading = QHttp::Reading, Connected = QHttp::Connected, Closing = QHttp::Closing}; | ||||
| public slots: | ||||
| QHttp* new_QHttp(QObject* parent = 0); | ||||
| QHttp* new_QHttp(const QString& hostname, QHttp::ConnectionMode mode, unsigned short port = 0, QObject* parent = 0); | ||||
| QHttp* new_QHttp(const QString& hostname, unsigned short port = 80, QObject* parent = 0); | ||||
| void delete_QHttp(QHttp* obj) { delete obj; } | ||||
|
florianlink
|
r120 | qint64 bytesAvailable(QHttp* theWrappedObject) const; | ||
|
florianlink
|
r128 | void clearPendingRequests(QHttp* theWrappedObject); | ||
| int close(QHttp* theWrappedObject); | ||||
| QIODevice* currentDestinationDevice(QHttp* theWrappedObject) const; | ||||
| int currentId(QHttp* theWrappedObject) const; | ||||
| QHttpRequestHeader currentRequest(QHttp* theWrappedObject) const; | ||||
| QIODevice* currentSourceDevice(QHttp* theWrappedObject) const; | ||||
|
florianlink
|
r120 | QHttp::Error error(QHttp* theWrappedObject) const; | ||
|
florianlink
|
r128 | QString errorString(QHttp* theWrappedObject) const; | ||
| int get(QHttp* theWrappedObject, const QString& path, QIODevice* to = 0); | ||||
| bool hasPendingRequests(QHttp* theWrappedObject) const; | ||||
|
florianlink
|
r120 | int head(QHttp* theWrappedObject, const QString& path); | ||
|
florianlink
|
r128 | QHttpResponseHeader lastResponse(QHttp* theWrappedObject) const; | ||
|
florianlink
|
r120 | int post(QHttp* theWrappedObject, const QString& path, QIODevice* data, QIODevice* to = 0); | ||
|
florianlink
|
r128 | int post(QHttp* theWrappedObject, const QString& path, const QByteArray& data, QIODevice* to = 0); | ||
| qint64 read(QHttp* theWrappedObject, char* data, qint64 maxlen); | ||||
|
florianlink
|
r99 | QByteArray readAll(QHttp* theWrappedObject); | ||
|
florianlink
|
r128 | int request(QHttp* theWrappedObject, const QHttpRequestHeader& header, QIODevice* device = 0, QIODevice* to = 0); | ||
| int request(QHttp* theWrappedObject, const QHttpRequestHeader& header, const QByteArray& data, QIODevice* to = 0); | ||||
|
florianlink
|
r120 | int setHost(QHttp* theWrappedObject, const QString& hostname, QHttp::ConnectionMode mode, unsigned short port = 0); | ||
|
florianlink
|
r99 | int setHost(QHttp* theWrappedObject, const QString& hostname, unsigned short port = 80); | ||
|
florianlink
|
r110 | int setProxy(QHttp* theWrappedObject, const QNetworkProxy& proxy); | ||
|
florianlink
|
r99 | int setProxy(QHttp* theWrappedObject, const QString& host, int port, const QString& username = QString(), const QString& password = QString()); | ||
|
florianlink
|
r128 | int setSocket(QHttp* theWrappedObject, QTcpSocket* socket); | ||
| int setUser(QHttp* theWrappedObject, const QString& username, const QString& password = QString()); | ||||
| QHttp::State state(QHttp* theWrappedObject) const; | ||||
|
florianlink
|
r99 | }; | ||
| class PythonQtShell_QHttpHeader : public QHttpHeader | ||||
| { | ||||
| public: | ||||
| PythonQtShell_QHttpHeader():QHttpHeader(),_wrapper(NULL) {}; | ||||
| PythonQtShell_QHttpHeader(const QString& str):QHttpHeader(str),_wrapper(NULL) {}; | ||||
|
florianlink
|
r186 | ~PythonQtShell_QHttpHeader(); | ||
|
florianlink
|
r99 | virtual int majorVersion() const; | ||
| virtual int minorVersion() const; | ||||
| virtual bool parseLine(const QString& line, int number); | ||||
|
florianlink
|
r128 | virtual QString toString() const; | ||
|
florianlink
|
r99 | |||
| PythonQtInstanceWrapper* _wrapper; | ||||
| }; | ||||
| class PythonQtPublicPromoter_QHttpHeader : public QHttpHeader | ||||
| { public: | ||||
| inline bool promoted_parseLine(const QString& line, int number) { return QHttpHeader::parseLine(line, number); } | ||||
|
florianlink
|
r128 | inline QString promoted_toString() const { return QHttpHeader::toString(); } | ||
|
florianlink
|
r99 | }; | ||
| class PythonQtWrapper_QHttpHeader : public QObject | ||||
| { Q_OBJECT | ||||
| public: | ||||
| public slots: | ||||
| QHttpHeader* new_QHttpHeader(); | ||||
| QHttpHeader* new_QHttpHeader(const QString& str); | ||||
| void delete_QHttpHeader(QHttpHeader* obj) { delete obj; } | ||||
|
florianlink
|
r128 | void addValue(QHttpHeader* theWrappedObject, const QString& key, const QString& value); | ||
|
florianlink
|
r99 | QStringList allValues(QHttpHeader* theWrappedObject, const QString& key) const; | ||
| uint contentLength(QHttpHeader* theWrappedObject) const; | ||||
|
florianlink
|
r128 | QString contentType(QHttpHeader* theWrappedObject) const; | ||
| bool hasContentLength(QHttpHeader* theWrappedObject) const; | ||||
| bool hasContentType(QHttpHeader* theWrappedObject) const; | ||||
| bool hasKey(QHttpHeader* theWrappedObject, const QString& key) const; | ||||
| bool isValid(QHttpHeader* theWrappedObject) const; | ||||
| QStringList keys(QHttpHeader* theWrappedObject) const; | ||||
|
florianlink
|
r110 | bool parseLine(QHttpHeader* theWrappedObject, const QString& line, int number); | ||
|
florianlink
|
r120 | void removeAllValues(QHttpHeader* theWrappedObject, const QString& key); | ||
|
florianlink
|
r128 | void removeValue(QHttpHeader* theWrappedObject, const QString& key); | ||
| void setContentLength(QHttpHeader* theWrappedObject, int len); | ||||
|
florianlink
|
r99 | void setContentType(QHttpHeader* theWrappedObject, const QString& type); | ||
|
florianlink
|
r128 | void setValue(QHttpHeader* theWrappedObject, const QString& key, const QString& value); | ||
| void setValues(QHttpHeader* theWrappedObject, const QList<QPair<QString , QString > >& values); | ||||
| QString toString(QHttpHeader* theWrappedObject) const; | ||||
| QString value(QHttpHeader* theWrappedObject, const QString& key) const; | ||||
| QList<QPair<QString , QString > > values(QHttpHeader* theWrappedObject) const; | ||||
|
florianlink
|
r117 | QString py_toString(QHttpHeader*); | ||
|
florianlink
|
r99 | }; | ||
|
florianlink
|
r186 | class PythonQtShell_QHttpMultiPart : public QHttpMultiPart | ||
| { | ||||
| public: | ||||
| PythonQtShell_QHttpMultiPart(QHttpMultiPart::ContentType contentType, QObject* parent = 0):QHttpMultiPart(contentType, parent),_wrapper(NULL) {}; | ||||
| PythonQtShell_QHttpMultiPart(QObject* parent = 0):QHttpMultiPart(parent),_wrapper(NULL) {}; | ||||
| ~PythonQtShell_QHttpMultiPart(); | ||||
| virtual void childEvent(QChildEvent* arg__1); | ||||
| virtual void customEvent(QEvent* arg__1); | ||||
| virtual bool event(QEvent* arg__1); | ||||
| virtual bool eventFilter(QObject* arg__1, QEvent* arg__2); | ||||
| virtual void timerEvent(QTimerEvent* arg__1); | ||||
| PythonQtInstanceWrapper* _wrapper; | ||||
| }; | ||||
| class PythonQtWrapper_QHttpMultiPart : public QObject | ||||
| { Q_OBJECT | ||||
| public: | ||||
| Q_ENUMS(ContentType ) | ||||
| enum ContentType{ | ||||
| MixedType = QHttpMultiPart::MixedType, RelatedType = QHttpMultiPart::RelatedType, FormDataType = QHttpMultiPart::FormDataType, AlternativeType = QHttpMultiPart::AlternativeType}; | ||||
| public slots: | ||||
| QHttpMultiPart* new_QHttpMultiPart(QHttpMultiPart::ContentType contentType, QObject* parent = 0); | ||||
| QHttpMultiPart* new_QHttpMultiPart(QObject* parent = 0); | ||||
| void delete_QHttpMultiPart(QHttpMultiPart* obj) { delete obj; } | ||||
| void append(QHttpMultiPart* theWrappedObject, const QHttpPart& httpPart); | ||||
| QByteArray boundary(QHttpMultiPart* theWrappedObject) const; | ||||
| void setBoundary(QHttpMultiPart* theWrappedObject, const QByteArray& boundary); | ||||
| void setContentType(QHttpMultiPart* theWrappedObject, QHttpMultiPart::ContentType contentType); | ||||
| }; | ||||
| class PythonQtWrapper_QHttpPart : public QObject | ||||
| { Q_OBJECT | ||||
| public: | ||||
| public slots: | ||||
| QHttpPart* new_QHttpPart(); | ||||
| QHttpPart* new_QHttpPart(const QHttpPart& other); | ||||
| void delete_QHttpPart(QHttpPart* obj) { delete obj; } | ||||
| bool __ne__(QHttpPart* theWrappedObject, const QHttpPart& other) const; | ||||
| QHttpPart* operator_assign(QHttpPart* theWrappedObject, const QHttpPart& other); | ||||
| bool __eq__(QHttpPart* theWrappedObject, const QHttpPart& other) const; | ||||
| void setBody(QHttpPart* theWrappedObject, const QByteArray& body); | ||||
| void setBodyDevice(QHttpPart* theWrappedObject, QIODevice* device); | ||||
| void setHeader(QHttpPart* theWrappedObject, QNetworkRequest::KnownHeaders header, const QVariant& value); | ||||
| void setRawHeader(QHttpPart* theWrappedObject, const QByteArray& headerName, const QByteArray& headerValue); | ||||
| }; | ||||
|
florianlink
|
r99 | class PythonQtShell_QHttpRequestHeader : public QHttpRequestHeader | ||
| { | ||||
| public: | ||||
| PythonQtShell_QHttpRequestHeader():QHttpRequestHeader(),_wrapper(NULL) {}; | ||||
| PythonQtShell_QHttpRequestHeader(const QHttpRequestHeader& header):QHttpRequestHeader(header),_wrapper(NULL) {}; | ||||
| PythonQtShell_QHttpRequestHeader(const QString& method, const QString& path, int majorVer = 1, int minorVer = 1):QHttpRequestHeader(method, path, majorVer, minorVer),_wrapper(NULL) {}; | ||||
| PythonQtShell_QHttpRequestHeader(const QString& str):QHttpRequestHeader(str),_wrapper(NULL) {}; | ||||
|
florianlink
|
r186 | ~PythonQtShell_QHttpRequestHeader(); | ||
|
florianlink
|
r128 | virtual int majorVersion() const; | ||
| virtual int minorVersion() const; | ||||
|
florianlink
|
r99 | virtual bool parseLine(const QString& line, int number); | ||
| virtual QString toString() const; | ||||
| PythonQtInstanceWrapper* _wrapper; | ||||
| }; | ||||
| class PythonQtPublicPromoter_QHttpRequestHeader : public QHttpRequestHeader | ||||
| { public: | ||||
|
florianlink
|
r128 | inline int promoted_majorVersion() const { return QHttpRequestHeader::majorVersion(); } | ||
| inline int promoted_minorVersion() const { return QHttpRequestHeader::minorVersion(); } | ||||
|
florianlink
|
r99 | inline bool promoted_parseLine(const QString& line, int number) { return QHttpRequestHeader::parseLine(line, number); } | ||
| inline QString promoted_toString() const { return QHttpRequestHeader::toString(); } | ||||
| }; | ||||
| class PythonQtWrapper_QHttpRequestHeader : public QObject | ||||
| { Q_OBJECT | ||||
| public: | ||||
| public slots: | ||||
| QHttpRequestHeader* new_QHttpRequestHeader(); | ||||
| QHttpRequestHeader* new_QHttpRequestHeader(const QHttpRequestHeader& header); | ||||
| QHttpRequestHeader* new_QHttpRequestHeader(const QString& method, const QString& path, int majorVer = 1, int minorVer = 1); | ||||
| QHttpRequestHeader* new_QHttpRequestHeader(const QString& str); | ||||
| void delete_QHttpRequestHeader(QHttpRequestHeader* obj) { delete obj; } | ||||
|
florianlink
|
r128 | int majorVersion(QHttpRequestHeader* theWrappedObject) const; | ||
|
florianlink
|
r99 | QString method(QHttpRequestHeader* theWrappedObject) const; | ||
|
florianlink
|
r128 | int minorVersion(QHttpRequestHeader* theWrappedObject) const; | ||
|
florianlink
|
r99 | bool parseLine(QHttpRequestHeader* theWrappedObject, const QString& line, int number); | ||
| QString path(QHttpRequestHeader* theWrappedObject) const; | ||||
| void setRequest(QHttpRequestHeader* theWrappedObject, const QString& method, const QString& path, int majorVer = 1, int minorVer = 1); | ||||
|
florianlink
|
r128 | QString toString(QHttpRequestHeader* theWrappedObject) const; | ||
|
florianlink
|
r117 | QString py_toString(QHttpRequestHeader*); | ||
|
florianlink
|
r99 | }; | ||
| class PythonQtShell_QHttpResponseHeader : public QHttpResponseHeader | ||||
| { | ||||
| public: | ||||
| PythonQtShell_QHttpResponseHeader():QHttpResponseHeader(),_wrapper(NULL) {}; | ||||
| PythonQtShell_QHttpResponseHeader(const QHttpResponseHeader& header):QHttpResponseHeader(header),_wrapper(NULL) {}; | ||||
| PythonQtShell_QHttpResponseHeader(const QString& str):QHttpResponseHeader(str),_wrapper(NULL) {}; | ||||
| PythonQtShell_QHttpResponseHeader(int code, const QString& text = QString(), int majorVer = 1, int minorVer = 1):QHttpResponseHeader(code, text, majorVer, minorVer),_wrapper(NULL) {}; | ||||
|
florianlink
|
r186 | ~PythonQtShell_QHttpResponseHeader(); | ||
|
florianlink
|
r128 | virtual int majorVersion() const; | ||
| virtual int minorVersion() const; | ||||
|
florianlink
|
r99 | virtual bool parseLine(const QString& line, int number); | ||
| virtual QString toString() const; | ||||
| PythonQtInstanceWrapper* _wrapper; | ||||
| }; | ||||
| class PythonQtPublicPromoter_QHttpResponseHeader : public QHttpResponseHeader | ||||
| { public: | ||||
|
florianlink
|
r128 | inline int promoted_majorVersion() const { return QHttpResponseHeader::majorVersion(); } | ||
| inline int promoted_minorVersion() const { return QHttpResponseHeader::minorVersion(); } | ||||
|
florianlink
|
r99 | inline bool promoted_parseLine(const QString& line, int number) { return QHttpResponseHeader::parseLine(line, number); } | ||
| inline QString promoted_toString() const { return QHttpResponseHeader::toString(); } | ||||
| }; | ||||
| class PythonQtWrapper_QHttpResponseHeader : public QObject | ||||
| { Q_OBJECT | ||||
| public: | ||||
| public slots: | ||||
| QHttpResponseHeader* new_QHttpResponseHeader(); | ||||
| QHttpResponseHeader* new_QHttpResponseHeader(const QHttpResponseHeader& header); | ||||
| QHttpResponseHeader* new_QHttpResponseHeader(const QString& str); | ||||
| QHttpResponseHeader* new_QHttpResponseHeader(int code, const QString& text = QString(), int majorVer = 1, int minorVer = 1); | ||||
| void delete_QHttpResponseHeader(QHttpResponseHeader* obj) { delete obj; } | ||||
|
florianlink
|
r128 | int majorVersion(QHttpResponseHeader* theWrappedObject) const; | ||
| int minorVersion(QHttpResponseHeader* theWrappedObject) const; | ||||
|
florianlink
|
r110 | bool parseLine(QHttpResponseHeader* theWrappedObject, const QString& line, int number); | ||
|
florianlink
|
r128 | QString reasonPhrase(QHttpResponseHeader* theWrappedObject) const; | ||
| void setStatusLine(QHttpResponseHeader* theWrappedObject, int code, const QString& text = QString(), int majorVer = 1, int minorVer = 1); | ||||
|
florianlink
|
r120 | int statusCode(QHttpResponseHeader* theWrappedObject) const; | ||
|
florianlink
|
r99 | QString toString(QHttpResponseHeader* theWrappedObject) const; | ||
|
florianlink
|
r117 | QString py_toString(QHttpResponseHeader*); | ||
|
florianlink
|
r99 | }; | ||
| class PythonQtShell_QIPv6Address : public QIPv6Address | ||||
| { | ||||
| public: | ||||
| PythonQtShell_QIPv6Address():QIPv6Address(),_wrapper(NULL) {}; | ||||
|
florianlink
|
r186 | ~PythonQtShell_QIPv6Address(); | ||
|
florianlink
|
r99 | |||
| PythonQtInstanceWrapper* _wrapper; | ||||
| }; | ||||
| class PythonQtWrapper_QIPv6Address : public QObject | ||||
| { Q_OBJECT | ||||
| public: | ||||
| public slots: | ||||
| QIPv6Address* new_QIPv6Address(); | ||||
| QIPv6Address* new_QIPv6Address(const QIPv6Address& other) { | ||||
| PythonQtShell_QIPv6Address* a = new PythonQtShell_QIPv6Address(); | ||||
| *((QIPv6Address*)a) = other; | ||||
| return a; } | ||||
| void delete_QIPv6Address(QIPv6Address* obj) { delete obj; } | ||||
| }; | ||||
| class PythonQtShell_QLocalServer : public QLocalServer | ||||
| { | ||||
| public: | ||||
| PythonQtShell_QLocalServer(QObject* parent = 0):QLocalServer(parent),_wrapper(NULL) {}; | ||||
|
florianlink
|
r186 | ~PythonQtShell_QLocalServer(); | ||
|
florianlink
|
r120 | virtual void childEvent(QChildEvent* arg__1); | ||
| virtual void customEvent(QEvent* arg__1); | ||||
|
florianlink
|
r128 | virtual bool event(QEvent* arg__1); | ||
| virtual bool eventFilter(QObject* arg__1, QEvent* arg__2); | ||||
| virtual bool hasPendingConnections() const; | ||||
| virtual void incomingConnection(quintptr socketDescriptor); | ||||
| virtual QLocalSocket* nextPendingConnection(); | ||||
|
florianlink
|
r120 | virtual void timerEvent(QTimerEvent* arg__1); | ||
|
florianlink
|
r99 | |||
| PythonQtInstanceWrapper* _wrapper; | ||||
| }; | ||||
| class PythonQtPublicPromoter_QLocalServer : public QLocalServer | ||||
| { public: | ||||
| inline bool promoted_hasPendingConnections() const { return QLocalServer::hasPendingConnections(); } | ||||
| inline void promoted_incomingConnection(quintptr socketDescriptor) { QLocalServer::incomingConnection(socketDescriptor); } | ||||
|
florianlink
|
r128 | inline QLocalSocket* promoted_nextPendingConnection() { return QLocalServer::nextPendingConnection(); } | ||
|
florianlink
|
r99 | }; | ||
| class PythonQtWrapper_QLocalServer : public QObject | ||||
| { Q_OBJECT | ||||
| public: | ||||
| public slots: | ||||
| QLocalServer* new_QLocalServer(QObject* parent = 0); | ||||
| void delete_QLocalServer(QLocalServer* obj) { delete obj; } | ||||
|
florianlink
|
r110 | void close(QLocalServer* theWrappedObject); | ||
| QString errorString(QLocalServer* theWrappedObject) const; | ||||
|
florianlink
|
r128 | QString fullServerName(QLocalServer* theWrappedObject) const; | ||
|
florianlink
|
r120 | bool hasPendingConnections(QLocalServer* theWrappedObject) const; | ||
|
florianlink
|
r128 | void incomingConnection(QLocalServer* theWrappedObject, quintptr socketDescriptor); | ||
| bool isListening(QLocalServer* theWrappedObject) const; | ||||
|
florianlink
|
r120 | bool listen(QLocalServer* theWrappedObject, const QString& name); | ||
|
florianlink
|
r128 | int maxPendingConnections(QLocalServer* theWrappedObject) const; | ||
| QLocalSocket* nextPendingConnection(QLocalServer* theWrappedObject); | ||||
|
florianlink
|
r110 | bool static_QLocalServer_removeServer(const QString& name); | ||
|
florianlink
|
r128 | QAbstractSocket::SocketError serverError(QLocalServer* theWrappedObject) const; | ||
| QString serverName(QLocalServer* theWrappedObject) const; | ||||
| void setMaxPendingConnections(QLocalServer* theWrappedObject, int numConnections); | ||||
| bool waitForNewConnection(QLocalServer* theWrappedObject, int msec = 0, bool* timedOut = 0); | ||||
|
florianlink
|
r99 | }; | ||
| class PythonQtShell_QLocalSocket : public QLocalSocket | ||||
| { | ||||
| public: | ||||
| PythonQtShell_QLocalSocket(QObject* parent = 0):QLocalSocket(parent),_wrapper(NULL) {}; | ||||
|
florianlink
|
r186 | ~PythonQtShell_QLocalSocket(); | ||
|
florianlink
|
r128 | virtual bool atEnd() const; | ||
|
florianlink
|
r99 | virtual qint64 bytesAvailable() const; | ||
|
florianlink
|
r128 | virtual qint64 bytesToWrite() const; | ||
|
florianlink
|
r120 | virtual bool canReadLine() const; | ||
|
florianlink
|
r128 | virtual void childEvent(QChildEvent* arg__1); | ||
| virtual void close(); | ||||
| virtual void customEvent(QEvent* arg__1); | ||||
| virtual bool event(QEvent* arg__1); | ||||
| virtual bool eventFilter(QObject* arg__1, QEvent* arg__2); | ||||
| virtual bool isSequential() const; | ||||
| virtual bool open(QIODevice::OpenMode mode); | ||||
| virtual qint64 pos() const; | ||||
|
florianlink
|
r117 | virtual qint64 readData(char* arg__1, qint64 arg__2); | ||
|
florianlink
|
r128 | virtual qint64 readLineData(char* data, qint64 maxlen); | ||
|
florianlink
|
r117 | virtual bool reset(); | ||
|
florianlink
|
r99 | virtual bool seek(qint64 pos); | ||
|
florianlink
|
r120 | virtual qint64 size() const; | ||
| virtual void timerEvent(QTimerEvent* arg__1); | ||||
|
florianlink
|
r128 | virtual bool waitForBytesWritten(int msecs = 30000); | ||
| virtual bool waitForReadyRead(int msecs = 30000); | ||||
| virtual qint64 writeData(const char* arg__1, qint64 arg__2); | ||||
|
florianlink
|
r99 | |||
| PythonQtInstanceWrapper* _wrapper; | ||||
| }; | ||||
| class PythonQtPublicPromoter_QLocalSocket : public QLocalSocket | ||||
| { public: | ||||
| inline qint64 promoted_bytesAvailable() const { return QLocalSocket::bytesAvailable(); } | ||||
|
florianlink
|
r128 | inline qint64 promoted_bytesToWrite() const { return QLocalSocket::bytesToWrite(); } | ||
|
florianlink
|
r120 | inline bool promoted_canReadLine() const { return QLocalSocket::canReadLine(); } | ||
|
florianlink
|
r128 | inline void promoted_close() { QLocalSocket::close(); } | ||
| inline bool promoted_isSequential() const { return QLocalSocket::isSequential(); } | ||||
|
florianlink
|
r117 | inline qint64 promoted_readData(char* arg__1, qint64 arg__2) { return QLocalSocket::readData(arg__1, arg__2); } | ||
|
florianlink
|
r128 | inline bool promoted_waitForBytesWritten(int msecs = 30000) { return QLocalSocket::waitForBytesWritten(msecs); } | ||
| inline bool promoted_waitForReadyRead(int msecs = 30000) { return QLocalSocket::waitForReadyRead(msecs); } | ||||
| inline qint64 promoted_writeData(const char* arg__1, qint64 arg__2) { return QLocalSocket::writeData(arg__1, arg__2); } | ||||
|
florianlink
|
r99 | }; | ||
| class PythonQtWrapper_QLocalSocket : public QObject | ||||
| { Q_OBJECT | ||||
| public: | ||||
| Q_ENUMS(LocalSocketState LocalSocketError ) | ||||
| enum LocalSocketState{ | ||||
| UnconnectedState = QLocalSocket::UnconnectedState, ConnectingState = QLocalSocket::ConnectingState, ConnectedState = QLocalSocket::ConnectedState, ClosingState = QLocalSocket::ClosingState}; | ||||
| enum LocalSocketError{ | ||||
| ConnectionRefusedError = QLocalSocket::ConnectionRefusedError, PeerClosedError = QLocalSocket::PeerClosedError, ServerNotFoundError = QLocalSocket::ServerNotFoundError, SocketAccessError = QLocalSocket::SocketAccessError, SocketResourceError = QLocalSocket::SocketResourceError, SocketTimeoutError = QLocalSocket::SocketTimeoutError, DatagramTooLargeError = QLocalSocket::DatagramTooLargeError, ConnectionError = QLocalSocket::ConnectionError, UnsupportedSocketOperationError = QLocalSocket::UnsupportedSocketOperationError, UnknownSocketError = QLocalSocket::UnknownSocketError}; | ||||
| public slots: | ||||
| QLocalSocket* new_QLocalSocket(QObject* parent = 0); | ||||
| void delete_QLocalSocket(QLocalSocket* obj) { delete obj; } | ||||
|
florianlink
|
r128 | void abort(QLocalSocket* theWrappedObject); | ||
|
florianlink
|
r120 | qint64 bytesAvailable(QLocalSocket* theWrappedObject) const; | ||
|
florianlink
|
r128 | qint64 bytesToWrite(QLocalSocket* theWrappedObject) const; | ||
| bool canReadLine(QLocalSocket* theWrappedObject) const; | ||||
| void close(QLocalSocket* theWrappedObject); | ||||
|
florianlink
|
r120 | void connectToServer(QLocalSocket* theWrappedObject, const QString& name, QIODevice::OpenMode openMode = QIODevice::ReadWrite); | ||
|
florianlink
|
r128 | void disconnectFromServer(QLocalSocket* theWrappedObject); | ||
|
florianlink
|
r99 | QLocalSocket::LocalSocketError error(QLocalSocket* theWrappedObject) const; | ||
|
florianlink
|
r120 | bool flush(QLocalSocket* theWrappedObject); | ||
|
florianlink
|
r99 | QString fullServerName(QLocalSocket* theWrappedObject) const; | ||
|
florianlink
|
r128 | bool isSequential(QLocalSocket* theWrappedObject) const; | ||
| bool isValid(QLocalSocket* theWrappedObject) const; | ||||
| qint64 readBufferSize(QLocalSocket* theWrappedObject) const; | ||||
|
florianlink
|
r117 | qint64 readData(QLocalSocket* theWrappedObject, char* arg__1, qint64 arg__2); | ||
|
florianlink
|
r128 | QString serverName(QLocalSocket* theWrappedObject) const; | ||
| void setReadBufferSize(QLocalSocket* theWrappedObject, qint64 size); | ||||
| bool setSocketDescriptor(QLocalSocket* theWrappedObject, quintptr socketDescriptor, QLocalSocket::LocalSocketState socketState = QLocalSocket::ConnectedState, QIODevice::OpenMode openMode = QIODevice::ReadWrite); | ||||
| quintptr socketDescriptor(QLocalSocket* theWrappedObject) const; | ||||
| QLocalSocket::LocalSocketState state(QLocalSocket* theWrappedObject) const; | ||||
| bool waitForBytesWritten(QLocalSocket* theWrappedObject, int msecs = 30000); | ||||
| bool waitForConnected(QLocalSocket* theWrappedObject, int msecs = 30000); | ||||
| bool waitForDisconnected(QLocalSocket* theWrappedObject, int msecs = 30000); | ||||
| bool waitForReadyRead(QLocalSocket* theWrappedObject, int msecs = 30000); | ||||
| qint64 writeData(QLocalSocket* theWrappedObject, const char* arg__1, qint64 arg__2); | ||||
|
florianlink
|
r99 | }; | ||
| class PythonQtShell_QNetworkAccessManager : public QNetworkAccessManager | ||||
| { | ||||
| public: | ||||
| PythonQtShell_QNetworkAccessManager(QObject* parent = 0):QNetworkAccessManager(parent),_wrapper(NULL) {}; | ||||
|
florianlink
|
r186 | ~PythonQtShell_QNetworkAccessManager(); | ||
|
florianlink
|
r128 | virtual void childEvent(QChildEvent* arg__1); | ||
|
florianlink
|
r99 | virtual QNetworkReply* createRequest(QNetworkAccessManager::Operation op, const QNetworkRequest& request, QIODevice* outgoingData = 0); | ||
|
florianlink
|
r128 | virtual void customEvent(QEvent* arg__1); | ||
|
florianlink
|
r117 | virtual bool event(QEvent* arg__1); | ||
|
florianlink
|
r99 | virtual bool eventFilter(QObject* arg__1, QEvent* arg__2); | ||
|
florianlink
|
r120 | virtual void timerEvent(QTimerEvent* arg__1); | ||
|
florianlink
|
r99 | |||
| PythonQtInstanceWrapper* _wrapper; | ||||
| }; | ||||
| class PythonQtPublicPromoter_QNetworkAccessManager : public QNetworkAccessManager | ||||
| { public: | ||||
| inline QNetworkReply* promoted_createRequest(QNetworkAccessManager::Operation op, const QNetworkRequest& request, QIODevice* outgoingData = 0) { return QNetworkAccessManager::createRequest(op, request, outgoingData); } | ||||
| }; | ||||
| class PythonQtWrapper_QNetworkAccessManager : public QObject | ||||
| { Q_OBJECT | ||||
| public: | ||||
|
florianlink
|
r186 | Q_ENUMS(NetworkAccessibility Operation ) | ||
| enum NetworkAccessibility{ | ||||
| UnknownAccessibility = QNetworkAccessManager::UnknownAccessibility, NotAccessible = QNetworkAccessManager::NotAccessible, Accessible = QNetworkAccessManager::Accessible}; | ||||
|
florianlink
|
r99 | enum Operation{ | ||
|
florianlink
|
r186 | HeadOperation = QNetworkAccessManager::HeadOperation, GetOperation = QNetworkAccessManager::GetOperation, PutOperation = QNetworkAccessManager::PutOperation, PostOperation = QNetworkAccessManager::PostOperation, DeleteOperation = QNetworkAccessManager::DeleteOperation, CustomOperation = QNetworkAccessManager::CustomOperation, UnknownOperation = QNetworkAccessManager::UnknownOperation}; | ||
|
florianlink
|
r99 | public slots: | ||
| QNetworkAccessManager* new_QNetworkAccessManager(QObject* parent = 0); | ||||
| void delete_QNetworkAccessManager(QNetworkAccessManager* obj) { delete obj; } | ||||
|
florianlink
|
r128 | QAbstractNetworkCache* cache(QNetworkAccessManager* theWrappedObject) const; | ||
| QNetworkCookieJar* cookieJar(QNetworkAccessManager* theWrappedObject) const; | ||||
| QNetworkReply* createRequest(QNetworkAccessManager* theWrappedObject, QNetworkAccessManager::Operation op, const QNetworkRequest& request, QIODevice* outgoingData = 0); | ||||
| QNetworkReply* deleteResource(QNetworkAccessManager* theWrappedObject, const QNetworkRequest& request); | ||||
|
florianlink
|
r120 | QNetworkReply* get(QNetworkAccessManager* theWrappedObject, const QNetworkRequest& request); | ||
|
florianlink
|
r99 | QNetworkReply* head(QNetworkAccessManager* theWrappedObject, const QNetworkRequest& request); | ||
|
florianlink
|
r186 | QNetworkAccessManager::NetworkAccessibility networkAccessible(QNetworkAccessManager* theWrappedObject) const; | ||
| QNetworkReply* post(QNetworkAccessManager* theWrappedObject, const QNetworkRequest& request, QHttpMultiPart* multiPart); | ||||
|
florianlink
|
r110 | QNetworkReply* post(QNetworkAccessManager* theWrappedObject, const QNetworkRequest& request, QIODevice* data); | ||
|
florianlink
|
r128 | QNetworkReply* post(QNetworkAccessManager* theWrappedObject, const QNetworkRequest& request, const QByteArray& data); | ||
| QNetworkProxy proxy(QNetworkAccessManager* theWrappedObject) const; | ||||
| QNetworkProxyFactory* proxyFactory(QNetworkAccessManager* theWrappedObject) const; | ||||
|
florianlink
|
r186 | QNetworkReply* put(QNetworkAccessManager* theWrappedObject, const QNetworkRequest& request, QHttpMultiPart* multiPart); | ||
|
florianlink
|
r120 | QNetworkReply* put(QNetworkAccessManager* theWrappedObject, const QNetworkRequest& request, QIODevice* data); | ||
|
florianlink
|
r99 | QNetworkReply* put(QNetworkAccessManager* theWrappedObject, const QNetworkRequest& request, const QByteArray& data); | ||
|
florianlink
|
r186 | QNetworkReply* sendCustomRequest(QNetworkAccessManager* theWrappedObject, const QNetworkRequest& request, const QByteArray& verb, QIODevice* data = 0); | ||
|
florianlink
|
r128 | void setCache(QNetworkAccessManager* theWrappedObject, QAbstractNetworkCache* cache); | ||
|
florianlink
|
r110 | void setCookieJar(QNetworkAccessManager* theWrappedObject, QNetworkCookieJar* cookieJar); | ||
|
florianlink
|
r186 | void setNetworkAccessible(QNetworkAccessManager* theWrappedObject, QNetworkAccessManager::NetworkAccessibility accessible); | ||
|
florianlink
|
r128 | void setProxy(QNetworkAccessManager* theWrappedObject, const QNetworkProxy& proxy); | ||
| void setProxyFactory(QNetworkAccessManager* theWrappedObject, QNetworkProxyFactory* factory); | ||||
|
florianlink
|
r99 | }; | ||
| class PythonQtWrapper_QNetworkAddressEntry : public QObject | ||||
| { Q_OBJECT | ||||
| public: | ||||
| public slots: | ||||
| QNetworkAddressEntry* new_QNetworkAddressEntry(); | ||||
| QNetworkAddressEntry* new_QNetworkAddressEntry(const QNetworkAddressEntry& other); | ||||
| void delete_QNetworkAddressEntry(QNetworkAddressEntry* obj) { delete obj; } | ||||
|
florianlink
|
r128 | QHostAddress broadcast(QNetworkAddressEntry* theWrappedObject) const; | ||
|
florianlink
|
r120 | QHostAddress ip(QNetworkAddressEntry* theWrappedObject) const; | ||
|
florianlink
|
r128 | QHostAddress netmask(QNetworkAddressEntry* theWrappedObject) const; | ||
| bool __ne__(QNetworkAddressEntry* theWrappedObject, const QNetworkAddressEntry& other) const; | ||||
|
florianlink
|
r120 | bool __eq__(QNetworkAddressEntry* theWrappedObject, const QNetworkAddressEntry& other) const; | ||
|
florianlink
|
r128 | int prefixLength(QNetworkAddressEntry* theWrappedObject) const; | ||
| void setBroadcast(QNetworkAddressEntry* theWrappedObject, const QHostAddress& newBroadcast); | ||||
|
florianlink
|
r120 | void setIp(QNetworkAddressEntry* theWrappedObject, const QHostAddress& newIp); | ||
|
florianlink
|
r99 | void setNetmask(QNetworkAddressEntry* theWrappedObject, const QHostAddress& newNetmask); | ||
|
florianlink
|
r128 | void setPrefixLength(QNetworkAddressEntry* theWrappedObject, int length); | ||
|
florianlink
|
r110 | }; | ||
| class PythonQtWrapper_QNetworkCacheMetaData : public QObject | ||||
| { Q_OBJECT | ||||
| public: | ||||
| public slots: | ||||
| QNetworkCacheMetaData* new_QNetworkCacheMetaData(); | ||||
| QNetworkCacheMetaData* new_QNetworkCacheMetaData(const QNetworkCacheMetaData& other); | ||||
| void delete_QNetworkCacheMetaData(QNetworkCacheMetaData* obj) { delete obj; } | ||||
| QHash<QNetworkRequest::Attribute , QVariant > attributes(QNetworkCacheMetaData* theWrappedObject) const; | ||||
| QDateTime expirationDate(QNetworkCacheMetaData* theWrappedObject) const; | ||||
|
florianlink
|
r128 | bool isValid(QNetworkCacheMetaData* theWrappedObject) const; | ||
|
florianlink
|
r110 | QDateTime lastModified(QNetworkCacheMetaData* theWrappedObject) const; | ||
|
florianlink
|
r120 | bool __ne__(QNetworkCacheMetaData* theWrappedObject, const QNetworkCacheMetaData& other) const; | ||
|
florianlink
|
r128 | void writeTo(QNetworkCacheMetaData* theWrappedObject, QDataStream& arg__1); | ||
| bool __eq__(QNetworkCacheMetaData* theWrappedObject, const QNetworkCacheMetaData& other) const; | ||||
| void readFrom(QNetworkCacheMetaData* theWrappedObject, QDataStream& arg__1); | ||||
| QList<QPair<QByteArray , QByteArray > > rawHeaders(QNetworkCacheMetaData* theWrappedObject) const; | ||||
|
florianlink
|
r120 | bool saveToDisk(QNetworkCacheMetaData* theWrappedObject) const; | ||
|
florianlink
|
r128 | void setAttributes(QNetworkCacheMetaData* theWrappedObject, const QHash<QNetworkRequest::Attribute , QVariant >& attributes); | ||
| void setExpirationDate(QNetworkCacheMetaData* theWrappedObject, const QDateTime& dateTime); | ||||
|
florianlink
|
r110 | void setLastModified(QNetworkCacheMetaData* theWrappedObject, const QDateTime& dateTime); | ||
| void setRawHeaders(QNetworkCacheMetaData* theWrappedObject, const QList<QPair<QByteArray , QByteArray > >& headers); | ||||
|
florianlink
|
r128 | void setSaveToDisk(QNetworkCacheMetaData* theWrappedObject, bool allow); | ||
|
florianlink
|
r110 | void setUrl(QNetworkCacheMetaData* theWrappedObject, const QUrl& url); | ||
|
florianlink
|
r128 | QUrl url(QNetworkCacheMetaData* theWrappedObject) const; | ||
|
florianlink
|
r99 | }; | ||
| class PythonQtWrapper_QNetworkCookie : public QObject | ||||
| { Q_OBJECT | ||||
| public: | ||||
| Q_ENUMS(RawForm ) | ||||
| enum RawForm{ | ||||
| NameAndValueOnly = QNetworkCookie::NameAndValueOnly, Full = QNetworkCookie::Full}; | ||||
| public slots: | ||||
| QNetworkCookie* new_QNetworkCookie(const QByteArray& name = QByteArray(), const QByteArray& value = QByteArray()); | ||||
| QNetworkCookie* new_QNetworkCookie(const QNetworkCookie& other); | ||||
| void delete_QNetworkCookie(QNetworkCookie* obj) { delete obj; } | ||||
|
florianlink
|
r128 | QString domain(QNetworkCookie* theWrappedObject) const; | ||
|
florianlink
|
r99 | QDateTime expirationDate(QNetworkCookie* theWrappedObject) const; | ||
|
florianlink
|
r128 | bool isHttpOnly(QNetworkCookie* theWrappedObject) const; | ||
| bool isSecure(QNetworkCookie* theWrappedObject) const; | ||||
|
florianlink
|
r120 | bool isSessionCookie(QNetworkCookie* theWrappedObject) const; | ||
|
florianlink
|
r99 | QByteArray name(QNetworkCookie* theWrappedObject) const; | ||
|
florianlink
|
r120 | bool __ne__(QNetworkCookie* theWrappedObject, const QNetworkCookie& other) const; | ||
| bool __eq__(QNetworkCookie* theWrappedObject, const QNetworkCookie& other) const; | ||||
|
florianlink
|
r128 | QList<QNetworkCookie > static_QNetworkCookie_parseCookies(const QByteArray& cookieString); | ||
| QString path(QNetworkCookie* theWrappedObject) const; | ||||
|
florianlink
|
r110 | void setDomain(QNetworkCookie* theWrappedObject, const QString& domain); | ||
| void setExpirationDate(QNetworkCookie* theWrappedObject, const QDateTime& date); | ||||
|
florianlink
|
r128 | void setHttpOnly(QNetworkCookie* theWrappedObject, bool enable); | ||
| void setName(QNetworkCookie* theWrappedObject, const QByteArray& cookieName); | ||||
|
florianlink
|
r120 | void setPath(QNetworkCookie* theWrappedObject, const QString& path); | ||
|
florianlink
|
r128 | void setSecure(QNetworkCookie* theWrappedObject, bool enable); | ||
| void setValue(QNetworkCookie* theWrappedObject, const QByteArray& value); | ||||
|
florianlink
|
r120 | QByteArray toRawForm(QNetworkCookie* theWrappedObject, QNetworkCookie::RawForm form = QNetworkCookie::Full) const; | ||
|
florianlink
|
r128 | QByteArray value(QNetworkCookie* theWrappedObject) const; | ||
|
florianlink
|
r117 | QString py_toString(QNetworkCookie*); | ||
|
florianlink
|
r99 | }; | ||
| class PythonQtShell_QNetworkCookieJar : public QNetworkCookieJar | ||||
| { | ||||
| public: | ||||
| PythonQtShell_QNetworkCookieJar(QObject* parent = 0):QNetworkCookieJar(parent),_wrapper(NULL) {}; | ||||
|
florianlink
|
r186 | ~PythonQtShell_QNetworkCookieJar(); | ||
|
florianlink
|
r128 | virtual void childEvent(QChildEvent* arg__1); | ||
|
florianlink
|
r99 | virtual QList<QNetworkCookie > cookiesForUrl(const QUrl& url) const; | ||
|
florianlink
|
r128 | virtual void customEvent(QEvent* arg__1); | ||
|
florianlink
|
r117 | virtual bool event(QEvent* arg__1); | ||
|
florianlink
|
r99 | virtual bool eventFilter(QObject* arg__1, QEvent* arg__2); | ||
|
florianlink
|
r128 | virtual bool setCookiesFromUrl(const QList<QNetworkCookie >& cookieList, const QUrl& url); | ||
|
florianlink
|
r120 | virtual void timerEvent(QTimerEvent* arg__1); | ||
|
florianlink
|
r99 | |||
| PythonQtInstanceWrapper* _wrapper; | ||||
| }; | ||||
| class PythonQtPublicPromoter_QNetworkCookieJar : public QNetworkCookieJar | ||||
| { public: | ||||
| inline QList<QNetworkCookie > promoted_cookiesForUrl(const QUrl& url) const { return QNetworkCookieJar::cookiesForUrl(url); } | ||||
|
florianlink
|
r128 | inline bool promoted_setCookiesFromUrl(const QList<QNetworkCookie >& cookieList, const QUrl& url) { return QNetworkCookieJar::setCookiesFromUrl(cookieList, url); } | ||
|
florianlink
|
r99 | }; | ||
| class PythonQtWrapper_QNetworkCookieJar : public QObject | ||||
| { Q_OBJECT | ||||
| public: | ||||
| public slots: | ||||
| QNetworkCookieJar* new_QNetworkCookieJar(QObject* parent = 0); | ||||
| void delete_QNetworkCookieJar(QNetworkCookieJar* obj) { delete obj; } | ||||
| QList<QNetworkCookie > cookiesForUrl(QNetworkCookieJar* theWrappedObject, const QUrl& url) const; | ||||
|
florianlink
|
r128 | bool setCookiesFromUrl(QNetworkCookieJar* theWrappedObject, const QList<QNetworkCookie >& cookieList, const QUrl& url); | ||
|
florianlink
|
r99 | }; | ||
|
florianlink
|
r110 | class PythonQtShell_QNetworkDiskCache : public QNetworkDiskCache | ||
| { | ||||
| public: | ||||
| PythonQtShell_QNetworkDiskCache(QObject* parent = 0):QNetworkDiskCache(parent),_wrapper(NULL) {}; | ||||
|
florianlink
|
r186 | ~PythonQtShell_QNetworkDiskCache(); | ||
|
florianlink
|
r110 | virtual qint64 cacheSize() const; | ||
|
florianlink
|
r128 | virtual void childEvent(QChildEvent* arg__1); | ||
| virtual void clear(); | ||||
| virtual void customEvent(QEvent* arg__1); | ||||
| virtual QIODevice* data(const QUrl& url); | ||||
|
florianlink
|
r120 | virtual bool event(QEvent* arg__1); | ||
|
florianlink
|
r128 | virtual bool eventFilter(QObject* arg__1, QEvent* arg__2); | ||
| virtual qint64 expire(); | ||||
|
florianlink
|
r110 | virtual void insert(QIODevice* device); | ||
|
florianlink
|
r128 | virtual QNetworkCacheMetaData metaData(const QUrl& url); | ||
| virtual QIODevice* prepare(const QNetworkCacheMetaData& metaData); | ||||
|
florianlink
|
r110 | virtual bool remove(const QUrl& url); | ||
|
florianlink
|
r120 | virtual void timerEvent(QTimerEvent* arg__1); | ||
|
florianlink
|
r128 | virtual void updateMetaData(const QNetworkCacheMetaData& metaData); | ||
|
florianlink
|
r110 | |||
| PythonQtInstanceWrapper* _wrapper; | ||||
| }; | ||||
| class PythonQtPublicPromoter_QNetworkDiskCache : public QNetworkDiskCache | ||||
| { public: | ||||
| inline qint64 promoted_cacheSize() const { return QNetworkDiskCache::cacheSize(); } | ||||
| inline void promoted_clear() { QNetworkDiskCache::clear(); } | ||||
|
florianlink
|
r128 | inline QIODevice* promoted_data(const QUrl& url) { return QNetworkDiskCache::data(url); } | ||
| inline qint64 promoted_expire() { return QNetworkDiskCache::expire(); } | ||||
| inline void promoted_insert(QIODevice* device) { QNetworkDiskCache::insert(device); } | ||||
| inline QNetworkCacheMetaData promoted_metaData(const QUrl& url) { return QNetworkDiskCache::metaData(url); } | ||||
| inline QIODevice* promoted_prepare(const QNetworkCacheMetaData& metaData) { return QNetworkDiskCache::prepare(metaData); } | ||||
| inline bool promoted_remove(const QUrl& url) { return QNetworkDiskCache::remove(url); } | ||||
| inline void promoted_updateMetaData(const QNetworkCacheMetaData& metaData) { QNetworkDiskCache::updateMetaData(metaData); } | ||||
|
florianlink
|
r110 | }; | ||
| class PythonQtWrapper_QNetworkDiskCache : public QObject | ||||
| { Q_OBJECT | ||||
| public: | ||||
| public slots: | ||||
| QNetworkDiskCache* new_QNetworkDiskCache(QObject* parent = 0); | ||||
| void delete_QNetworkDiskCache(QNetworkDiskCache* obj) { delete obj; } | ||||
| QString cacheDirectory(QNetworkDiskCache* theWrappedObject) const; | ||||
| qint64 cacheSize(QNetworkDiskCache* theWrappedObject) const; | ||||
|
florianlink
|
r186 | void clear(QNetworkDiskCache* theWrappedObject); | ||
|
florianlink
|
r128 | QIODevice* data(QNetworkDiskCache* theWrappedObject, const QUrl& url); | ||
| qint64 expire(QNetworkDiskCache* theWrappedObject); | ||||
|
florianlink
|
r110 | QNetworkCacheMetaData fileMetaData(QNetworkDiskCache* theWrappedObject, const QString& fileName) const; | ||
| void insert(QNetworkDiskCache* theWrappedObject, QIODevice* device); | ||||
|
florianlink
|
r128 | qint64 maximumCacheSize(QNetworkDiskCache* theWrappedObject) const; | ||
| QNetworkCacheMetaData metaData(QNetworkDiskCache* theWrappedObject, const QUrl& url); | ||||
| QIODevice* prepare(QNetworkDiskCache* theWrappedObject, const QNetworkCacheMetaData& metaData); | ||||
|
florianlink
|
r110 | bool remove(QNetworkDiskCache* theWrappedObject, const QUrl& url); | ||
|
florianlink
|
r120 | void setCacheDirectory(QNetworkDiskCache* theWrappedObject, const QString& cacheDir); | ||
|
florianlink
|
r128 | void setMaximumCacheSize(QNetworkDiskCache* theWrappedObject, qint64 size); | ||
| void updateMetaData(QNetworkDiskCache* theWrappedObject, const QNetworkCacheMetaData& metaData); | ||||
|
florianlink
|
r110 | }; | ||
|
florianlink
|
r99 | class PythonQtWrapper_QNetworkInterface : public QObject | ||
| { Q_OBJECT | ||||
| public: | ||||
| Q_ENUMS(InterfaceFlag ) | ||||
| Q_FLAGS(InterfaceFlags ) | ||||
| enum InterfaceFlag{ | ||||
| IsUp = QNetworkInterface::IsUp, IsRunning = QNetworkInterface::IsRunning, CanBroadcast = QNetworkInterface::CanBroadcast, IsLoopBack = QNetworkInterface::IsLoopBack, IsPointToPoint = QNetworkInterface::IsPointToPoint, CanMulticast = QNetworkInterface::CanMulticast}; | ||||
| Q_DECLARE_FLAGS(InterfaceFlags, InterfaceFlag) | ||||
| public slots: | ||||
| QNetworkInterface* new_QNetworkInterface(); | ||||
| QNetworkInterface* new_QNetworkInterface(const QNetworkInterface& other); | ||||
| void delete_QNetworkInterface(QNetworkInterface* obj) { delete obj; } | ||||
|
florianlink
|
r120 | QList<QNetworkAddressEntry > addressEntries(QNetworkInterface* theWrappedObject) const; | ||
|
florianlink
|
r128 | QList<QHostAddress > static_QNetworkInterface_allAddresses(); | ||
|
florianlink
|
r110 | QList<QNetworkInterface > static_QNetworkInterface_allInterfaces(); | ||
|
florianlink
|
r128 | QNetworkInterface::InterfaceFlags flags(QNetworkInterface* theWrappedObject) const; | ||
| QString hardwareAddress(QNetworkInterface* theWrappedObject) const; | ||||
| QString humanReadableName(QNetworkInterface* theWrappedObject) const; | ||||
|
florianlink
|
r110 | int index(QNetworkInterface* theWrappedObject) const; | ||
|
florianlink
|
r128 | QNetworkInterface static_QNetworkInterface_interfaceFromIndex(int index); | ||
|
florianlink
|
r120 | QNetworkInterface static_QNetworkInterface_interfaceFromName(const QString& name); | ||
|
florianlink
|
r128 | bool isValid(QNetworkInterface* theWrappedObject) const; | ||
|
florianlink
|
r120 | QString name(QNetworkInterface* theWrappedObject) const; | ||
|
florianlink
|
r117 | QString py_toString(QNetworkInterface*); | ||
|
florianlink
|
r99 | }; | ||
| class PythonQtWrapper_QNetworkProxy : public QObject | ||||
| { Q_OBJECT | ||||
| public: | ||||
|
florianlink
|
r110 | Q_ENUMS(ProxyType Capability ) | ||
| Q_FLAGS(Capabilities ) | ||||
|
florianlink
|
r99 | enum ProxyType{ | ||
| DefaultProxy = QNetworkProxy::DefaultProxy, Socks5Proxy = QNetworkProxy::Socks5Proxy, NoProxy = QNetworkProxy::NoProxy, HttpProxy = QNetworkProxy::HttpProxy, HttpCachingProxy = QNetworkProxy::HttpCachingProxy, FtpCachingProxy = QNetworkProxy::FtpCachingProxy}; | ||||
|
florianlink
|
r110 | enum Capability{ | ||
| TunnelingCapability = QNetworkProxy::TunnelingCapability, ListeningCapability = QNetworkProxy::ListeningCapability, UdpTunnelingCapability = QNetworkProxy::UdpTunnelingCapability, CachingCapability = QNetworkProxy::CachingCapability, HostNameLookupCapability = QNetworkProxy::HostNameLookupCapability}; | ||||
| Q_DECLARE_FLAGS(Capabilities, Capability) | ||||
|
florianlink
|
r99 | public slots: | ||
| QNetworkProxy* new_QNetworkProxy(); | ||||
| QNetworkProxy* new_QNetworkProxy(QNetworkProxy::ProxyType type, const QString& hostName = QString(), unsigned short port = 0, const QString& user = QString(), const QString& password = QString()); | ||||
| QNetworkProxy* new_QNetworkProxy(const QNetworkProxy& other); | ||||
| void delete_QNetworkProxy(QNetworkProxy* obj) { delete obj; } | ||||
| QNetworkProxy static_QNetworkProxy_applicationProxy(); | ||||
|
florianlink
|
r128 | QNetworkProxy::Capabilities capabilities(QNetworkProxy* theWrappedObject) const; | ||
|
florianlink
|
r99 | QString hostName(QNetworkProxy* theWrappedObject) const; | ||
|
florianlink
|
r110 | bool isCachingProxy(QNetworkProxy* theWrappedObject) const; | ||
|
florianlink
|
r128 | bool isTransparentProxy(QNetworkProxy* theWrappedObject) const; | ||
| bool __ne__(QNetworkProxy* theWrappedObject, const QNetworkProxy& other) const; | ||||
|
florianlink
|
r120 | bool __eq__(QNetworkProxy* theWrappedObject, const QNetworkProxy& other) const; | ||
| QString password(QNetworkProxy* theWrappedObject) const; | ||||
|
florianlink
|
r128 | unsigned short port(QNetworkProxy* theWrappedObject) const; | ||
| void static_QNetworkProxy_setApplicationProxy(const QNetworkProxy& proxy); | ||||
| void setCapabilities(QNetworkProxy* theWrappedObject, QNetworkProxy::Capabilities capab); | ||||
|
florianlink
|
r99 | void setHostName(QNetworkProxy* theWrappedObject, const QString& hostName); | ||
|
florianlink
|
r128 | void setPassword(QNetworkProxy* theWrappedObject, const QString& password); | ||
| void setPort(QNetworkProxy* theWrappedObject, unsigned short port); | ||||
| void setType(QNetworkProxy* theWrappedObject, QNetworkProxy::ProxyType type); | ||||
|
florianlink
|
r99 | void setUser(QNetworkProxy* theWrappedObject, const QString& userName); | ||
|
florianlink
|
r120 | QNetworkProxy::ProxyType type(QNetworkProxy* theWrappedObject) const; | ||
|
florianlink
|
r128 | QString user(QNetworkProxy* theWrappedObject) const; | ||
|
florianlink
|
r99 | }; | ||
|
florianlink
|
r110 | class PythonQtShell_QNetworkProxyFactory : public QNetworkProxyFactory | ||
| { | ||||
| public: | ||||
| PythonQtShell_QNetworkProxyFactory():QNetworkProxyFactory(),_wrapper(NULL) {}; | ||||
|
florianlink
|
r186 | ~PythonQtShell_QNetworkProxyFactory(); | ||
|
florianlink
|
r110 | virtual QList<QNetworkProxy > queryProxy(const QNetworkProxyQuery& query = QNetworkProxyQuery()); | ||
| PythonQtInstanceWrapper* _wrapper; | ||||
| }; | ||||
| class PythonQtWrapper_QNetworkProxyFactory : public QObject | ||||
| { Q_OBJECT | ||||
| public: | ||||
| public slots: | ||||
| QNetworkProxyFactory* new_QNetworkProxyFactory(); | ||||
| void delete_QNetworkProxyFactory(QNetworkProxyFactory* obj) { delete obj; } | ||||
|
florianlink
|
r128 | QList<QNetworkProxy > static_QNetworkProxyFactory_proxyForQuery(const QNetworkProxyQuery& query); | ||
|
florianlink
|
r110 | void static_QNetworkProxyFactory_setApplicationProxyFactory(QNetworkProxyFactory* factory); | ||
|
florianlink
|
r128 | void static_QNetworkProxyFactory_setUseSystemConfiguration(bool enable); | ||
|
florianlink
|
r110 | QList<QNetworkProxy > static_QNetworkProxyFactory_systemProxyForQuery(const QNetworkProxyQuery& query = QNetworkProxyQuery()); | ||
| }; | ||||
| class PythonQtWrapper_QNetworkProxyQuery : public QObject | ||||
| { Q_OBJECT | ||||
| public: | ||||
| Q_ENUMS(QueryType ) | ||||
| enum QueryType{ | ||||
| TcpSocket = QNetworkProxyQuery::TcpSocket, UdpSocket = QNetworkProxyQuery::UdpSocket, TcpServer = QNetworkProxyQuery::TcpServer, UrlRequest = QNetworkProxyQuery::UrlRequest}; | ||||
| public slots: | ||||
| QNetworkProxyQuery* new_QNetworkProxyQuery(); | ||||
| QNetworkProxyQuery* new_QNetworkProxyQuery(const QNetworkProxyQuery& other); | ||||
| QNetworkProxyQuery* new_QNetworkProxyQuery(const QString& hostname, int port, const QString& protocolTag = QString(), QNetworkProxyQuery::QueryType queryType = QNetworkProxyQuery::TcpSocket); | ||||
| QNetworkProxyQuery* new_QNetworkProxyQuery(const QUrl& requestUrl, QNetworkProxyQuery::QueryType queryType = QNetworkProxyQuery::UrlRequest); | ||||
| QNetworkProxyQuery* new_QNetworkProxyQuery(unsigned short bindPort, const QString& protocolTag = QString(), QNetworkProxyQuery::QueryType queryType = QNetworkProxyQuery::TcpServer); | ||||
| void delete_QNetworkProxyQuery(QNetworkProxyQuery* obj) { delete obj; } | ||||
|
florianlink
|
r128 | int localPort(QNetworkProxyQuery* theWrappedObject) const; | ||
|
florianlink
|
r120 | bool __ne__(QNetworkProxyQuery* theWrappedObject, const QNetworkProxyQuery& other) const; | ||
|
florianlink
|
r128 | bool __eq__(QNetworkProxyQuery* theWrappedObject, const QNetworkProxyQuery& other) const; | ||
| QString peerHostName(QNetworkProxyQuery* theWrappedObject) const; | ||||
| int peerPort(QNetworkProxyQuery* theWrappedObject) const; | ||||
| QString protocolTag(QNetworkProxyQuery* theWrappedObject) const; | ||||
|
florianlink
|
r110 | QNetworkProxyQuery::QueryType queryType(QNetworkProxyQuery* theWrappedObject) const; | ||
| void setLocalPort(QNetworkProxyQuery* theWrappedObject, int port); | ||||
|
florianlink
|
r120 | void setPeerHostName(QNetworkProxyQuery* theWrappedObject, const QString& hostname); | ||
|
florianlink
|
r128 | void setPeerPort(QNetworkProxyQuery* theWrappedObject, int port); | ||
| void setProtocolTag(QNetworkProxyQuery* theWrappedObject, const QString& protocolTag); | ||||
| void setQueryType(QNetworkProxyQuery* theWrappedObject, QNetworkProxyQuery::QueryType type); | ||||
|
florianlink
|
r110 | void setUrl(QNetworkProxyQuery* theWrappedObject, const QUrl& url); | ||
|
florianlink
|
r128 | QUrl url(QNetworkProxyQuery* theWrappedObject) const; | ||
|
florianlink
|
r110 | }; | ||
|
florianlink
|
r99 | class PythonQtShell_QNetworkReply : public QNetworkReply | ||
| { | ||||
| public: | ||||
| PythonQtShell_QNetworkReply(QObject* parent = 0):QNetworkReply(parent),_wrapper(NULL) {}; | ||||
|
florianlink
|
r186 | ~PythonQtShell_QNetworkReply(); | ||
|
florianlink
|
r99 | virtual void abort(); | ||
|
florianlink
|
r128 | virtual bool atEnd() const; | ||
|
florianlink
|
r117 | virtual qint64 bytesAvailable() const; | ||
|
florianlink
|
r128 | virtual qint64 bytesToWrite() const; | ||
|
florianlink
|
r120 | virtual bool canReadLine() const; | ||
|
florianlink
|
r128 | virtual void childEvent(QChildEvent* arg__1); | ||
| virtual void close(); | ||||
| virtual void customEvent(QEvent* arg__1); | ||||
| virtual bool event(QEvent* arg__1); | ||||
| virtual bool eventFilter(QObject* arg__1, QEvent* arg__2); | ||||
| virtual void ignoreSslErrors(); | ||||
| virtual bool isSequential() const; | ||||
|
florianlink
|
r120 | virtual bool open(QIODevice::OpenMode mode); | ||
|
florianlink
|
r128 | virtual qint64 pos() const; | ||
|
florianlink
|
r120 | virtual qint64 readData(char* data, qint64 maxlen); | ||
|
florianlink
|
r128 | virtual qint64 readLineData(char* data, qint64 maxlen); | ||
| virtual bool reset(); | ||||
| virtual bool seek(qint64 pos); | ||||
| virtual void setReadBufferSize(qint64 size); | ||||
|
florianlink
|
r120 | virtual qint64 size() const; | ||
| virtual void timerEvent(QTimerEvent* arg__1); | ||||
|
florianlink
|
r128 | virtual bool waitForBytesWritten(int msecs); | ||
| virtual bool waitForReadyRead(int msecs); | ||||
| virtual qint64 writeData(const char* data, qint64 len); | ||||
|
florianlink
|
r99 | |||
| PythonQtInstanceWrapper* _wrapper; | ||||
| }; | ||||
| class PythonQtPublicPromoter_QNetworkReply : public QNetworkReply | ||||
| { public: | ||||
|
florianlink
|
r120 | inline void promoted_close() { QNetworkReply::close(); } | ||
| inline void promoted_ignoreSslErrors() { QNetworkReply::ignoreSslErrors(); } | ||||
|
florianlink
|
r128 | inline bool promoted_isSequential() const { return QNetworkReply::isSequential(); } | ||
| inline void promoted_setReadBufferSize(qint64 size) { QNetworkReply::setReadBufferSize(size); } | ||||
| inline qint64 promoted_writeData(const char* data, qint64 len) { return QNetworkReply::writeData(data, len); } | ||||
|
florianlink
|
r99 | }; | ||
| class PythonQtWrapper_QNetworkReply : public QObject | ||||
| { Q_OBJECT | ||||
| public: | ||||
| public slots: | ||||
| void delete_QNetworkReply(QNetworkReply* obj) { delete obj; } | ||||
|
florianlink
|
r128 | QVariant attribute(QNetworkReply* theWrappedObject, QNetworkRequest::Attribute code) const; | ||
|
florianlink
|
r120 | void close(QNetworkReply* theWrappedObject); | ||
| QNetworkReply::NetworkError error(QNetworkReply* theWrappedObject) const; | ||||
|
florianlink
|
r128 | bool hasRawHeader(QNetworkReply* theWrappedObject, const QByteArray& headerName) const; | ||
| QVariant header(QNetworkReply* theWrappedObject, QNetworkRequest::KnownHeaders header) const; | ||||
|
florianlink
|
r186 | void ignoreSslErrors(QNetworkReply* theWrappedObject); | ||
|
florianlink
|
r120 | bool isFinished(QNetworkReply* theWrappedObject) const; | ||
|
florianlink
|
r128 | bool isRunning(QNetworkReply* theWrappedObject) const; | ||
| bool isSequential(QNetworkReply* theWrappedObject) const; | ||||
|
florianlink
|
r120 | QNetworkAccessManager* manager(QNetworkReply* theWrappedObject) const; | ||
|
florianlink
|
r128 | QNetworkAccessManager::Operation operation(QNetworkReply* theWrappedObject) const; | ||
| QByteArray rawHeader(QNetworkReply* theWrappedObject, const QByteArray& headerName) const; | ||||
| QList<QByteArray > rawHeaderList(QNetworkReply* theWrappedObject) const; | ||||
|
florianlink
|
r186 | const QList<QPair<QByteArray , QByteArray > >* rawHeaderPairs(QNetworkReply* theWrappedObject) const; | ||
|
florianlink
|
r128 | qint64 readBufferSize(QNetworkReply* theWrappedObject) const; | ||
| QNetworkRequest request(QNetworkReply* theWrappedObject) const; | ||||
| void setReadBufferSize(QNetworkReply* theWrappedObject, qint64 size); | ||||
|
florianlink
|
r120 | QUrl url(QNetworkReply* theWrappedObject) const; | ||
|
florianlink
|
r128 | qint64 writeData(QNetworkReply* theWrappedObject, const char* data, qint64 len); | ||
|
florianlink
|
r99 | }; | ||
| class PythonQtWrapper_QNetworkRequest : public QObject | ||||
| { Q_OBJECT | ||||
| public: | ||||
|
florianlink
|
r186 | Q_ENUMS(CacheLoadControl KnownHeaders Priority Attribute LoadControl ) | ||
|
florianlink
|
r99 | enum CacheLoadControl{ | ||
| AlwaysNetwork = QNetworkRequest::AlwaysNetwork, PreferNetwork = QNetworkRequest::PreferNetwork, PreferCache = QNetworkRequest::PreferCache, AlwaysCache = QNetworkRequest::AlwaysCache}; | ||||
| enum KnownHeaders{ | ||||
|
florianlink
|
r186 | ContentTypeHeader = QNetworkRequest::ContentTypeHeader, ContentLengthHeader = QNetworkRequest::ContentLengthHeader, LocationHeader = QNetworkRequest::LocationHeader, LastModifiedHeader = QNetworkRequest::LastModifiedHeader, CookieHeader = QNetworkRequest::CookieHeader, SetCookieHeader = QNetworkRequest::SetCookieHeader, ContentDispositionHeader = QNetworkRequest::ContentDispositionHeader}; | ||
| enum Priority{ | ||||
| HighPriority = QNetworkRequest::HighPriority, NormalPriority = QNetworkRequest::NormalPriority, LowPriority = QNetworkRequest::LowPriority}; | ||||
|
florianlink
|
r99 | enum Attribute{ | ||
|
florianlink
|
r186 | HttpStatusCodeAttribute = QNetworkRequest::HttpStatusCodeAttribute, HttpReasonPhraseAttribute = QNetworkRequest::HttpReasonPhraseAttribute, RedirectionTargetAttribute = QNetworkRequest::RedirectionTargetAttribute, ConnectionEncryptedAttribute = QNetworkRequest::ConnectionEncryptedAttribute, CacheLoadControlAttribute = QNetworkRequest::CacheLoadControlAttribute, CacheSaveControlAttribute = QNetworkRequest::CacheSaveControlAttribute, SourceIsFromCacheAttribute = QNetworkRequest::SourceIsFromCacheAttribute, DoNotBufferUploadDataAttribute = QNetworkRequest::DoNotBufferUploadDataAttribute, HttpPipeliningAllowedAttribute = QNetworkRequest::HttpPipeliningAllowedAttribute, HttpPipeliningWasUsedAttribute = QNetworkRequest::HttpPipeliningWasUsedAttribute, CustomVerbAttribute = QNetworkRequest::CustomVerbAttribute, CookieLoadControlAttribute = QNetworkRequest::CookieLoadControlAttribute, AuthenticationReuseAttribute = QNetworkRequest::AuthenticationReuseAttribute, CookieSaveControlAttribute = QNetworkRequest::CookieSaveControlAttribute, MaximumDownloadBufferSizeAttribute = QNetworkRequest::MaximumDownloadBufferSizeAttribute, DownloadBufferAttribute = QNetworkRequest::DownloadBufferAttribute, SynchronousRequestAttribute = QNetworkRequest::SynchronousRequestAttribute, User = QNetworkRequest::User, UserMax = QNetworkRequest::UserMax}; | ||
| enum LoadControl{ | ||||
| Automatic = QNetworkRequest::Automatic, Manual = QNetworkRequest::Manual}; | ||||
|
florianlink
|
r99 | public slots: | ||
| QNetworkRequest* new_QNetworkRequest(const QNetworkRequest& other); | ||||
| QNetworkRequest* new_QNetworkRequest(const QUrl& url = QUrl()); | ||||
| void delete_QNetworkRequest(QNetworkRequest* obj) { delete obj; } | ||||
|
florianlink
|
r128 | QVariant attribute(QNetworkRequest* theWrappedObject, QNetworkRequest::Attribute code, const QVariant& defaultValue = QVariant()) const; | ||
| bool hasRawHeader(QNetworkRequest* theWrappedObject, const QByteArray& headerName) const; | ||||
|
florianlink
|
r110 | QVariant header(QNetworkRequest* theWrappedObject, QNetworkRequest::KnownHeaders header) const; | ||
|
florianlink
|
r128 | bool __ne__(QNetworkRequest* theWrappedObject, const QNetworkRequest& other) const; | ||
| bool __eq__(QNetworkRequest* theWrappedObject, const QNetworkRequest& other) const; | ||||
| QObject* originatingObject(QNetworkRequest* theWrappedObject) const; | ||||
|
florianlink
|
r186 | QNetworkRequest::Priority priority(QNetworkRequest* theWrappedObject) const; | ||
|
florianlink
|
r120 | QByteArray rawHeader(QNetworkRequest* theWrappedObject, const QByteArray& headerName) const; | ||
|
florianlink
|
r128 | QList<QByteArray > rawHeaderList(QNetworkRequest* theWrappedObject) const; | ||
|
florianlink
|
r110 | void setAttribute(QNetworkRequest* theWrappedObject, QNetworkRequest::Attribute code, const QVariant& value); | ||
|
florianlink
|
r128 | void setHeader(QNetworkRequest* theWrappedObject, QNetworkRequest::KnownHeaders header, const QVariant& value); | ||
| void setOriginatingObject(QNetworkRequest* theWrappedObject, QObject* object); | ||||
|
florianlink
|
r186 | void setPriority(QNetworkRequest* theWrappedObject, QNetworkRequest::Priority priority); | ||
|
florianlink
|
r110 | void setRawHeader(QNetworkRequest* theWrappedObject, const QByteArray& headerName, const QByteArray& value); | ||
|
florianlink
|
r120 | void setUrl(QNetworkRequest* theWrappedObject, const QUrl& url); | ||
| QUrl url(QNetworkRequest* theWrappedObject) const; | ||||
|
florianlink
|
r99 | }; | ||
| class PythonQtWrapper_QSsl : public QObject | ||||
| { Q_OBJECT | ||||
| public: | ||||
|
florianlink
|
r186 | Q_ENUMS(KeyType KeyAlgorithm SslProtocol AlternateNameEntryType SslOption EncodingFormat ) | ||
| Q_FLAGS(SslOptions ) | ||||
|
florianlink
|
r99 | enum KeyType{ | ||
| PrivateKey = QSsl::PrivateKey, PublicKey = QSsl::PublicKey}; | ||||
| enum KeyAlgorithm{ | ||||
| Rsa = QSsl::Rsa, Dsa = QSsl::Dsa}; | ||||
| enum SslProtocol{ | ||||
|
florianlink
|
r186 | SslV3 = QSsl::SslV3, SslV2 = QSsl::SslV2, TlsV1 = QSsl::TlsV1, AnyProtocol = QSsl::AnyProtocol, TlsV1SslV3 = QSsl::TlsV1SslV3, SecureProtocols = QSsl::SecureProtocols, UnknownProtocol = QSsl::UnknownProtocol}; | ||
|
florianlink
|
r99 | enum AlternateNameEntryType{ | ||
| EmailEntry = QSsl::EmailEntry, DnsEntry = QSsl::DnsEntry}; | ||||
|
florianlink
|
r186 | enum SslOption{ | ||
| SslOptionDisableEmptyFragments = QSsl::SslOptionDisableEmptyFragments, SslOptionDisableSessionTickets = QSsl::SslOptionDisableSessionTickets, SslOptionDisableCompression = QSsl::SslOptionDisableCompression, SslOptionDisableServerNameIndication = QSsl::SslOptionDisableServerNameIndication, SslOptionDisableLegacyRenegotiation = QSsl::SslOptionDisableLegacyRenegotiation}; | ||||
|
florianlink
|
r99 | enum EncodingFormat{ | ||
| Pem = QSsl::Pem, Der = QSsl::Der}; | ||||
|
florianlink
|
r186 | Q_DECLARE_FLAGS(SslOptions, SslOption) | ||
|
florianlink
|
r99 | public slots: | ||
| }; | ||||
|
florianlink
|
r120 | class PythonQtShell_QTcpServer : public QTcpServer | ||
| { | ||||
| public: | ||||
| PythonQtShell_QTcpServer(QObject* parent = 0):QTcpServer(parent),_wrapper(NULL) {}; | ||||
|
florianlink
|
r186 | ~PythonQtShell_QTcpServer(); | ||
|
florianlink
|
r120 | virtual void childEvent(QChildEvent* arg__1); | ||
| virtual void customEvent(QEvent* arg__1); | ||||
|
florianlink
|
r128 | virtual bool event(QEvent* arg__1); | ||
| virtual bool eventFilter(QObject* arg__1, QEvent* arg__2); | ||||
| virtual bool hasPendingConnections() const; | ||||
| virtual void incomingConnection(int handle); | ||||
| virtual QTcpSocket* nextPendingConnection(); | ||||
|
florianlink
|
r120 | virtual void timerEvent(QTimerEvent* arg__1); | ||
| PythonQtInstanceWrapper* _wrapper; | ||||
| }; | ||||
| class PythonQtPublicPromoter_QTcpServer : public QTcpServer | ||||
| { public: | ||||
| inline bool promoted_hasPendingConnections() const { return QTcpServer::hasPendingConnections(); } | ||||
| inline void promoted_incomingConnection(int handle) { QTcpServer::incomingConnection(handle); } | ||||
|
florianlink
|
r128 | inline QTcpSocket* promoted_nextPendingConnection() { return QTcpServer::nextPendingConnection(); } | ||
|
florianlink
|
r120 | }; | ||
| class PythonQtWrapper_QTcpServer : public QObject | ||||
|
florianlink
|
r99 | { Q_OBJECT | ||
| public: | ||||
| public slots: | ||||
|
florianlink
|
r120 | QTcpServer* new_QTcpServer(QObject* parent = 0); | ||
| void delete_QTcpServer(QTcpServer* obj) { delete obj; } | ||||
|
florianlink
|
r128 | void close(QTcpServer* theWrappedObject); | ||
| QString errorString(QTcpServer* theWrappedObject) const; | ||||
| bool hasPendingConnections(QTcpServer* theWrappedObject) const; | ||||
| void incomingConnection(QTcpServer* theWrappedObject, int handle); | ||||
| bool isListening(QTcpServer* theWrappedObject) const; | ||||
| bool listen(QTcpServer* theWrappedObject, const QHostAddress& address = QHostAddress::Any, unsigned short port = 0); | ||||
|
florianlink
|
r120 | int maxPendingConnections(QTcpServer* theWrappedObject) const; | ||
| QTcpSocket* nextPendingConnection(QTcpServer* theWrappedObject); | ||||
|
florianlink
|
r128 | QNetworkProxy proxy(QTcpServer* theWrappedObject) const; | ||
|
florianlink
|
r120 | QHostAddress serverAddress(QTcpServer* theWrappedObject) const; | ||
|
florianlink
|
r128 | QAbstractSocket::SocketError serverError(QTcpServer* theWrappedObject) const; | ||
|
florianlink
|
r120 | unsigned short serverPort(QTcpServer* theWrappedObject) const; | ||
| void setMaxPendingConnections(QTcpServer* theWrappedObject, int numConnections); | ||||
|
florianlink
|
r128 | void setProxy(QTcpServer* theWrappedObject, const QNetworkProxy& networkProxy); | ||
|
florianlink
|
r120 | bool setSocketDescriptor(QTcpServer* theWrappedObject, int socketDescriptor); | ||
|
florianlink
|
r128 | int socketDescriptor(QTcpServer* theWrappedObject) const; | ||
| bool waitForNewConnection(QTcpServer* theWrappedObject, int msec = 0, bool* timedOut = 0); | ||||
|
florianlink
|
r99 | }; | ||
|
florianlink
|
r120 | class PythonQtShell_QTcpSocket : public QTcpSocket | ||
| { | ||||
| public: | ||||
| PythonQtShell_QTcpSocket(QObject* parent = 0):QTcpSocket(parent),_wrapper(NULL) {}; | ||||
|
florianlink
|
r186 | ~PythonQtShell_QTcpSocket(); | ||
|
florianlink
|
r128 | virtual bool atEnd() const; | ||
| virtual qint64 bytesAvailable() const; | ||||
| virtual qint64 bytesToWrite() const; | ||||
| virtual bool canReadLine() const; | ||||
| virtual void childEvent(QChildEvent* arg__1); | ||||
|
florianlink
|
r120 | virtual void close(); | ||
|
florianlink
|
r128 | virtual void customEvent(QEvent* arg__1); | ||
| virtual bool event(QEvent* arg__1); | ||||
| virtual bool eventFilter(QObject* arg__1, QEvent* arg__2); | ||||
| virtual bool isSequential() const; | ||||
| virtual bool open(QIODevice::OpenMode mode); | ||||
| virtual qint64 pos() const; | ||||
|
florianlink
|
r120 | virtual qint64 readData(char* data, qint64 maxlen); | ||
| virtual qint64 readLineData(char* data, qint64 maxlen); | ||||
| virtual bool reset(); | ||||
| virtual bool seek(qint64 pos); | ||||
| virtual qint64 size() const; | ||||
| virtual void timerEvent(QTimerEvent* arg__1); | ||||
|
florianlink
|
r128 | virtual bool waitForBytesWritten(int msecs); | ||
| virtual bool waitForReadyRead(int msecs); | ||||
| virtual qint64 writeData(const char* data, qint64 len); | ||||
|
florianlink
|
r120 | |||
| PythonQtInstanceWrapper* _wrapper; | ||||
| }; | ||||
| class PythonQtWrapper_QTcpSocket : public QObject | ||||
|
florianlink
|
r99 | { Q_OBJECT | ||
| public: | ||||
| public slots: | ||||
|
florianlink
|
r120 | QTcpSocket* new_QTcpSocket(QObject* parent = 0); | ||
| void delete_QTcpSocket(QTcpSocket* obj) { delete obj; } | ||||
|
florianlink
|
r99 | }; | ||