|
|
#include <PythonQt.h>
|
|
|
#include <QObject>
|
|
|
#include <QTextCodec>
|
|
|
#include <QVariant>
|
|
|
#include <qanimationgroup.h>
|
|
|
#include <qbytearray.h>
|
|
|
#include <qcoreevent.h>
|
|
|
#include <qdatastream.h>
|
|
|
#include <qeasingcurve.h>
|
|
|
#include <qfile.h>
|
|
|
#include <qiodevice.h>
|
|
|
#include <qlist.h>
|
|
|
#include <qlocale.h>
|
|
|
#include <qmutex.h>
|
|
|
#include <qobject.h>
|
|
|
#include <qpair.h>
|
|
|
#include <qreadwritelock.h>
|
|
|
#include <qrunnable.h>
|
|
|
#include <qsystemsemaphore.h>
|
|
|
#include <qtconcurrentexception.h>
|
|
|
#include <qtconcurrentreducekernel.h>
|
|
|
#include <qtconcurrentthreadengine.h>
|
|
|
#include <qtemporaryfile.h>
|
|
|
#include <qtextboundaryfinder.h>
|
|
|
#include <qtextcodec.h>
|
|
|
#include <qtextstream.h>
|
|
|
#include <qthreadpool.h>
|
|
|
#include <qtimeline.h>
|
|
|
#include <qtimer.h>
|
|
|
#include <qtranslator.h>
|
|
|
#include <quuid.h>
|
|
|
#include <qvariantanimation.h>
|
|
|
#include <qvector.h>
|
|
|
#include <qwaitcondition.h>
|
|
|
#include <qxmlstream.h>
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtWrapper_QSystemSemaphore : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
Q_ENUMS(AccessMode SystemSemaphoreError )
|
|
|
enum AccessMode{
|
|
|
Open = QSystemSemaphore::Open, Create = QSystemSemaphore::Create};
|
|
|
enum SystemSemaphoreError{
|
|
|
NoError = QSystemSemaphore::NoError, PermissionDenied = QSystemSemaphore::PermissionDenied, KeyError = QSystemSemaphore::KeyError, AlreadyExists = QSystemSemaphore::AlreadyExists, NotFound = QSystemSemaphore::NotFound, OutOfResources = QSystemSemaphore::OutOfResources, UnknownError = QSystemSemaphore::UnknownError};
|
|
|
public slots:
|
|
|
QSystemSemaphore* new_QSystemSemaphore(const QString& key, int initialValue = 0, QSystemSemaphore::AccessMode mode = QSystemSemaphore::Open);
|
|
|
void delete_QSystemSemaphore(QSystemSemaphore* obj) { delete obj; }
|
|
|
bool acquire(QSystemSemaphore* theWrappedObject);
|
|
|
QSystemSemaphore::SystemSemaphoreError error(QSystemSemaphore* theWrappedObject) const;
|
|
|
QString errorString(QSystemSemaphore* theWrappedObject) const;
|
|
|
QString key(QSystemSemaphore* theWrappedObject) const;
|
|
|
bool release(QSystemSemaphore* theWrappedObject, int n = 1);
|
|
|
void setKey(QSystemSemaphore* theWrappedObject, const QString& key, int initialValue = 0, QSystemSemaphore::AccessMode mode = QSystemSemaphore::Open);
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QTemporaryFile : public QTemporaryFile
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QTemporaryFile():QTemporaryFile(),_wrapper(NULL) {};
|
|
|
PythonQtShell_QTemporaryFile(QObject* parent):QTemporaryFile(parent),_wrapper(NULL) {};
|
|
|
PythonQtShell_QTemporaryFile(const QString& templateName):QTemporaryFile(templateName),_wrapper(NULL) {};
|
|
|
PythonQtShell_QTemporaryFile(const QString& templateName, QObject* parent):QTemporaryFile(templateName, parent),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QTemporaryFile();
|
|
|
|
|
|
virtual bool atEnd() const;
|
|
|
virtual qint64 bytesAvailable() const;
|
|
|
virtual qint64 bytesToWrite() const;
|
|
|
virtual bool canReadLine() const;
|
|
|
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 QAbstractFileEngine* fileEngine() const;
|
|
|
virtual bool isSequential() const;
|
|
|
virtual bool open(QIODevice::OpenMode flags);
|
|
|
virtual qint64 pos() const;
|
|
|
virtual qint64 readData(char* data, qint64 maxlen);
|
|
|
virtual qint64 readLineData(char* data, qint64 maxlen);
|
|
|
virtual bool reset();
|
|
|
virtual bool seek(qint64 offset);
|
|
|
virtual qint64 size() const;
|
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
|
virtual bool waitForBytesWritten(int msecs);
|
|
|
virtual bool waitForReadyRead(int msecs);
|
|
|
virtual qint64 writeData(const char* data, qint64 len);
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtPublicPromoter_QTemporaryFile : public QTemporaryFile
|
|
|
{ public:
|
|
|
inline QAbstractFileEngine* promoted_fileEngine() const { return QTemporaryFile::fileEngine(); }
|
|
|
inline bool promoted_open(QIODevice::OpenMode flags) { return QTemporaryFile::open(flags); }
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QTemporaryFile : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QTemporaryFile* new_QTemporaryFile();
|
|
|
QTemporaryFile* new_QTemporaryFile(QObject* parent);
|
|
|
QTemporaryFile* new_QTemporaryFile(const QString& templateName);
|
|
|
QTemporaryFile* new_QTemporaryFile(const QString& templateName, QObject* parent);
|
|
|
void delete_QTemporaryFile(QTemporaryFile* obj) { delete obj; }
|
|
|
bool autoRemove(QTemporaryFile* theWrappedObject) const;
|
|
|
QTemporaryFile* static_QTemporaryFile_createLocalFile(QFile& file);
|
|
|
QTemporaryFile* static_QTemporaryFile_createLocalFile(const QString& fileName);
|
|
|
QAbstractFileEngine* fileEngine(QTemporaryFile* theWrappedObject) const;
|
|
|
QString fileName(QTemporaryFile* theWrappedObject) const;
|
|
|
QString fileTemplate(QTemporaryFile* theWrappedObject) const;
|
|
|
bool open(QTemporaryFile* theWrappedObject);
|
|
|
bool open(QTemporaryFile* theWrappedObject, QIODevice::OpenMode flags);
|
|
|
void setAutoRemove(QTemporaryFile* theWrappedObject, bool b);
|
|
|
void setFileTemplate(QTemporaryFile* theWrappedObject, const QString& name);
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtWrapper_QTextBoundaryFinder : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
Q_ENUMS(BoundaryReason BoundaryType )
|
|
|
Q_FLAGS(BoundaryReasons )
|
|
|
enum BoundaryReason{
|
|
|
NotAtBoundary = QTextBoundaryFinder::NotAtBoundary, StartWord = QTextBoundaryFinder::StartWord, EndWord = QTextBoundaryFinder::EndWord};
|
|
|
enum BoundaryType{
|
|
|
Grapheme = QTextBoundaryFinder::Grapheme, Word = QTextBoundaryFinder::Word, Line = QTextBoundaryFinder::Line, Sentence = QTextBoundaryFinder::Sentence};
|
|
|
Q_DECLARE_FLAGS(BoundaryReasons, BoundaryReason)
|
|
|
public slots:
|
|
|
QTextBoundaryFinder* new_QTextBoundaryFinder();
|
|
|
QTextBoundaryFinder* new_QTextBoundaryFinder(QTextBoundaryFinder::BoundaryType type, const QString& string);
|
|
|
QTextBoundaryFinder* new_QTextBoundaryFinder(const QTextBoundaryFinder& other);
|
|
|
void delete_QTextBoundaryFinder(QTextBoundaryFinder* obj) { delete obj; }
|
|
|
QTextBoundaryFinder::BoundaryReasons boundaryReasons(QTextBoundaryFinder* theWrappedObject) const;
|
|
|
bool isAtBoundary(QTextBoundaryFinder* theWrappedObject) const;
|
|
|
bool isValid(QTextBoundaryFinder* theWrappedObject) const;
|
|
|
int position(QTextBoundaryFinder* theWrappedObject) const;
|
|
|
void setPosition(QTextBoundaryFinder* theWrappedObject, int position);
|
|
|
QString string(QTextBoundaryFinder* theWrappedObject) const;
|
|
|
void toEnd(QTextBoundaryFinder* theWrappedObject);
|
|
|
int toNextBoundary(QTextBoundaryFinder* theWrappedObject);
|
|
|
int toPreviousBoundary(QTextBoundaryFinder* theWrappedObject);
|
|
|
void toStart(QTextBoundaryFinder* theWrappedObject);
|
|
|
QTextBoundaryFinder::BoundaryType type(QTextBoundaryFinder* theWrappedObject) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QTextCodec : public QTextCodec
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QTextCodec():QTextCodec(),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QTextCodec();
|
|
|
|
|
|
virtual QList<QByteArray > aliases() const;
|
|
|
virtual QByteArray convertFromUnicode(const QChar* in, int length, QTextCodec::ConverterState* state) const;
|
|
|
virtual QString convertToUnicode(const char* in, int length, QTextCodec::ConverterState* state) const;
|
|
|
virtual int mibEnum() const;
|
|
|
virtual QByteArray name() const;
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtPublicPromoter_QTextCodec : public QTextCodec
|
|
|
{ public:
|
|
|
inline QList<QByteArray > promoted_aliases() const { return QTextCodec::aliases(); }
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QTextCodec : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
Q_ENUMS(ConversionFlag )
|
|
|
Q_FLAGS(ConversionFlags )
|
|
|
enum ConversionFlag{
|
|
|
DefaultConversion = QTextCodec::DefaultConversion, ConvertInvalidToNull = QTextCodec::ConvertInvalidToNull, IgnoreHeader = QTextCodec::IgnoreHeader, FreeFunction = QTextCodec::FreeFunction};
|
|
|
Q_DECLARE_FLAGS(ConversionFlags, ConversionFlag)
|
|
|
public slots:
|
|
|
QList<QByteArray > aliases(QTextCodec* theWrappedObject) const;
|
|
|
QList<QByteArray > static_QTextCodec_availableCodecs();
|
|
|
QList<int > static_QTextCodec_availableMibs();
|
|
|
bool canEncode(QTextCodec* theWrappedObject, QChar arg__1) const;
|
|
|
bool canEncode(QTextCodec* theWrappedObject, const QString& arg__1) const;
|
|
|
QTextCodec* static_QTextCodec_codecForCStrings();
|
|
|
QTextCodec* static_QTextCodec_codecForHtml(const QByteArray& ba);
|
|
|
QTextCodec* static_QTextCodec_codecForHtml(const QByteArray& ba, QTextCodec* defaultCodec);
|
|
|
QTextCodec* static_QTextCodec_codecForLocale();
|
|
|
QTextCodec* static_QTextCodec_codecForMib(int mib);
|
|
|
QTextCodec* static_QTextCodec_codecForName(const QByteArray& name);
|
|
|
QTextCodec* static_QTextCodec_codecForName(const char* name);
|
|
|
QTextCodec* static_QTextCodec_codecForUtfText(const QByteArray& ba);
|
|
|
QTextCodec* static_QTextCodec_codecForUtfText(const QByteArray& ba, QTextCodec* defaultCodec);
|
|
|
QByteArray fromUnicode(QTextCodec* theWrappedObject, const QString& uc) const;
|
|
|
QTextDecoder* makeDecoder(QTextCodec* theWrappedObject) const;
|
|
|
QTextDecoder* makeDecoder(QTextCodec* theWrappedObject, QTextCodec::ConversionFlags flags) const;
|
|
|
QTextEncoder* makeEncoder(QTextCodec* theWrappedObject) const;
|
|
|
QTextEncoder* makeEncoder(QTextCodec* theWrappedObject, QTextCodec::ConversionFlags flags) const;
|
|
|
void static_QTextCodec_setCodecForCStrings(QTextCodec* c);
|
|
|
void static_QTextCodec_setCodecForLocale(QTextCodec* c);
|
|
|
void static_QTextCodec_setCodecForTr(QTextCodec* c);
|
|
|
QString toUnicode(QTextCodec* theWrappedObject, const QByteArray& arg__1) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtWrapper_QTextDecoder : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QTextDecoder* new_QTextDecoder(const QTextCodec* codec);
|
|
|
QTextDecoder* new_QTextDecoder(const QTextCodec* codec, QTextCodec::ConversionFlags flags);
|
|
|
void delete_QTextDecoder(QTextDecoder* obj) { delete obj; }
|
|
|
bool hasFailure(QTextDecoder* theWrappedObject) const;
|
|
|
QString toUnicode(QTextDecoder* theWrappedObject, const QByteArray& ba);
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtWrapper_QTextEncoder : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QTextEncoder* new_QTextEncoder(const QTextCodec* codec);
|
|
|
QTextEncoder* new_QTextEncoder(const QTextCodec* codec, QTextCodec::ConversionFlags flags);
|
|
|
void delete_QTextEncoder(QTextEncoder* obj) { delete obj; }
|
|
|
QByteArray fromUnicode(QTextEncoder* theWrappedObject, const QString& str);
|
|
|
bool hasFailure(QTextEncoder* theWrappedObject) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QTextStream : public QTextStream
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QTextStream():QTextStream(),_wrapper(NULL) {};
|
|
|
PythonQtShell_QTextStream(QIODevice* device):QTextStream(device),_wrapper(NULL) {};
|
|
|
PythonQtShell_QTextStream(const QByteArray& array, QIODevice::OpenMode openMode = QIODevice::ReadOnly):QTextStream(array, openMode),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QTextStream();
|
|
|
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QTextStream : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
Q_ENUMS(RealNumberNotation NumberFlag FieldAlignment Status )
|
|
|
Q_FLAGS(NumberFlags )
|
|
|
enum RealNumberNotation{
|
|
|
SmartNotation = QTextStream::SmartNotation, FixedNotation = QTextStream::FixedNotation, ScientificNotation = QTextStream::ScientificNotation};
|
|
|
enum NumberFlag{
|
|
|
ShowBase = QTextStream::ShowBase, ForcePoint = QTextStream::ForcePoint, ForceSign = QTextStream::ForceSign, UppercaseBase = QTextStream::UppercaseBase, UppercaseDigits = QTextStream::UppercaseDigits};
|
|
|
enum FieldAlignment{
|
|
|
AlignLeft = QTextStream::AlignLeft, AlignRight = QTextStream::AlignRight, AlignCenter = QTextStream::AlignCenter, AlignAccountingStyle = QTextStream::AlignAccountingStyle};
|
|
|
enum Status{
|
|
|
Ok = QTextStream::Ok, ReadPastEnd = QTextStream::ReadPastEnd, ReadCorruptData = QTextStream::ReadCorruptData, WriteFailed = QTextStream::WriteFailed};
|
|
|
Q_DECLARE_FLAGS(NumberFlags, NumberFlag)
|
|
|
public slots:
|
|
|
QTextStream* new_QTextStream();
|
|
|
QTextStream* new_QTextStream(QIODevice* device);
|
|
|
QTextStream* new_QTextStream(const QByteArray& array, QIODevice::OpenMode openMode = QIODevice::ReadOnly);
|
|
|
void delete_QTextStream(QTextStream* obj) { delete obj; }
|
|
|
bool atEnd(QTextStream* theWrappedObject) const;
|
|
|
bool autoDetectUnicode(QTextStream* theWrappedObject) const;
|
|
|
QTextCodec* codec(QTextStream* theWrappedObject) const;
|
|
|
QIODevice* device(QTextStream* theWrappedObject) const;
|
|
|
QTextStream::FieldAlignment fieldAlignment(QTextStream* theWrappedObject) const;
|
|
|
int fieldWidth(QTextStream* theWrappedObject) const;
|
|
|
void flush(QTextStream* theWrappedObject);
|
|
|
bool generateByteOrderMark(QTextStream* theWrappedObject) const;
|
|
|
int integerBase(QTextStream* theWrappedObject) const;
|
|
|
QLocale locale(QTextStream* theWrappedObject) const;
|
|
|
QTextStream::NumberFlags numberFlags(QTextStream* theWrappedObject) const;
|
|
|
QTextStream* writeBoolean(QTextStream* theWrappedObject, QBool b);
|
|
|
QTextStream* writeByte(QTextStream* theWrappedObject, char ch);
|
|
|
QTextStream* writeDouble(QTextStream* theWrappedObject, double f);
|
|
|
QTextStream* writeFloat(QTextStream* theWrappedObject, float f);
|
|
|
QTextStream* writeLongLong(QTextStream* theWrappedObject, qlonglong i);
|
|
|
QTextStream* writeInt(QTextStream* theWrappedObject, signed int i);
|
|
|
QTextStream* writeShort(QTextStream* theWrappedObject, signed short i);
|
|
|
QTextStream* readByte(QTextStream* theWrappedObject, char& ch);
|
|
|
QTextStream* readDouble(QTextStream* theWrappedObject, double& f);
|
|
|
QTextStream* readFloat(QTextStream* theWrappedObject, float& f);
|
|
|
QTextStream* readLongLong(QTextStream* theWrappedObject, qlonglong& i);
|
|
|
QTextStream* readInt(QTextStream* theWrappedObject, signed int& i);
|
|
|
QTextStream* readShort(QTextStream* theWrappedObject, signed short& i);
|
|
|
QChar padChar(QTextStream* theWrappedObject) const;
|
|
|
qint64 pos(QTextStream* theWrappedObject) const;
|
|
|
QString read(QTextStream* theWrappedObject, qint64 maxlen);
|
|
|
QString readAll(QTextStream* theWrappedObject);
|
|
|
QString readLine(QTextStream* theWrappedObject, qint64 maxlen = 0);
|
|
|
QTextStream::RealNumberNotation realNumberNotation(QTextStream* theWrappedObject) const;
|
|
|
int realNumberPrecision(QTextStream* theWrappedObject) const;
|
|
|
void reset(QTextStream* theWrappedObject);
|
|
|
void resetStatus(QTextStream* theWrappedObject);
|
|
|
bool seek(QTextStream* theWrappedObject, qint64 pos);
|
|
|
void setAutoDetectUnicode(QTextStream* theWrappedObject, bool enabled);
|
|
|
void setCodec(QTextStream* theWrappedObject, QTextCodec* codec);
|
|
|
void setCodec(QTextStream* theWrappedObject, const char* codecName);
|
|
|
void setDevice(QTextStream* theWrappedObject, QIODevice* device);
|
|
|
void setFieldAlignment(QTextStream* theWrappedObject, QTextStream::FieldAlignment alignment);
|
|
|
void setFieldWidth(QTextStream* theWrappedObject, int width);
|
|
|
void setGenerateByteOrderMark(QTextStream* theWrappedObject, bool generate);
|
|
|
void setIntegerBase(QTextStream* theWrappedObject, int base);
|
|
|
void setLocale(QTextStream* theWrappedObject, const QLocale& locale);
|
|
|
void setNumberFlags(QTextStream* theWrappedObject, QTextStream::NumberFlags flags);
|
|
|
void setPadChar(QTextStream* theWrappedObject, QChar ch);
|
|
|
void setRealNumberNotation(QTextStream* theWrappedObject, QTextStream::RealNumberNotation notation);
|
|
|
void setRealNumberPrecision(QTextStream* theWrappedObject, int precision);
|
|
|
void setStatus(QTextStream* theWrappedObject, QTextStream::Status status);
|
|
|
void skipWhiteSpace(QTextStream* theWrappedObject);
|
|
|
QTextStream::Status status(QTextStream* theWrappedObject) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QThreadPool : public QThreadPool
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QThreadPool(QObject* parent = 0):QThreadPool(parent),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QThreadPool();
|
|
|
|
|
|
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_QThreadPool : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QThreadPool* new_QThreadPool(QObject* parent = 0);
|
|
|
void delete_QThreadPool(QThreadPool* obj) { delete obj; }
|
|
|
int activeThreadCount(QThreadPool* theWrappedObject) const;
|
|
|
int expiryTimeout(QThreadPool* theWrappedObject) const;
|
|
|
QThreadPool* static_QThreadPool_globalInstance();
|
|
|
int maxThreadCount(QThreadPool* theWrappedObject) const;
|
|
|
void releaseThread(QThreadPool* theWrappedObject);
|
|
|
void reserveThread(QThreadPool* theWrappedObject);
|
|
|
void setExpiryTimeout(QThreadPool* theWrappedObject, int expiryTimeout);
|
|
|
void setMaxThreadCount(QThreadPool* theWrappedObject, int maxThreadCount);
|
|
|
void start(QThreadPool* theWrappedObject, QRunnable* runnable, int priority = 0);
|
|
|
bool tryStart(QThreadPool* theWrappedObject, QRunnable* runnable);
|
|
|
void waitForDone(QThreadPool* theWrappedObject);
|
|
|
bool waitForDone(QThreadPool* theWrappedObject, int msecs);
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QTimeLine : public QTimeLine
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QTimeLine(int duration = 1000, QObject* parent = 0):QTimeLine(duration, parent),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QTimeLine();
|
|
|
|
|
|
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* event);
|
|
|
virtual qreal valueForTime(int msec) const;
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtPublicPromoter_QTimeLine : public QTimeLine
|
|
|
{ public:
|
|
|
inline void promoted_timerEvent(QTimerEvent* event) { QTimeLine::timerEvent(event); }
|
|
|
inline qreal promoted_valueForTime(int msec) const { return QTimeLine::valueForTime(msec); }
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QTimeLine : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
Q_ENUMS(Direction CurveShape State )
|
|
|
enum Direction{
|
|
|
Forward = QTimeLine::Forward, Backward = QTimeLine::Backward};
|
|
|
enum CurveShape{
|
|
|
EaseInCurve = QTimeLine::EaseInCurve, EaseOutCurve = QTimeLine::EaseOutCurve, EaseInOutCurve = QTimeLine::EaseInOutCurve, LinearCurve = QTimeLine::LinearCurve, SineCurve = QTimeLine::SineCurve, CosineCurve = QTimeLine::CosineCurve};
|
|
|
enum State{
|
|
|
NotRunning = QTimeLine::NotRunning, Paused = QTimeLine::Paused, Running = QTimeLine::Running};
|
|
|
public slots:
|
|
|
QTimeLine* new_QTimeLine(int duration = 1000, QObject* parent = 0);
|
|
|
void delete_QTimeLine(QTimeLine* obj) { delete obj; }
|
|
|
int currentFrame(QTimeLine* theWrappedObject) const;
|
|
|
int currentTime(QTimeLine* theWrappedObject) const;
|
|
|
qreal currentValue(QTimeLine* theWrappedObject) const;
|
|
|
QTimeLine::CurveShape curveShape(QTimeLine* theWrappedObject) const;
|
|
|
QTimeLine::Direction direction(QTimeLine* theWrappedObject) const;
|
|
|
int duration(QTimeLine* theWrappedObject) const;
|
|
|
QEasingCurve easingCurve(QTimeLine* theWrappedObject) const;
|
|
|
int endFrame(QTimeLine* theWrappedObject) const;
|
|
|
int frameForTime(QTimeLine* theWrappedObject, int msec) const;
|
|
|
int loopCount(QTimeLine* theWrappedObject) const;
|
|
|
void setCurveShape(QTimeLine* theWrappedObject, QTimeLine::CurveShape shape);
|
|
|
void setDirection(QTimeLine* theWrappedObject, QTimeLine::Direction direction);
|
|
|
void setDuration(QTimeLine* theWrappedObject, int duration);
|
|
|
void setEasingCurve(QTimeLine* theWrappedObject, const QEasingCurve& curve);
|
|
|
void setEndFrame(QTimeLine* theWrappedObject, int frame);
|
|
|
void setFrameRange(QTimeLine* theWrappedObject, int startFrame, int endFrame);
|
|
|
void setLoopCount(QTimeLine* theWrappedObject, int count);
|
|
|
void setStartFrame(QTimeLine* theWrappedObject, int frame);
|
|
|
void setUpdateInterval(QTimeLine* theWrappedObject, int interval);
|
|
|
int startFrame(QTimeLine* theWrappedObject) const;
|
|
|
QTimeLine::State state(QTimeLine* theWrappedObject) const;
|
|
|
void timerEvent(QTimeLine* theWrappedObject, QTimerEvent* event);
|
|
|
int updateInterval(QTimeLine* theWrappedObject) const;
|
|
|
qreal valueForTime(QTimeLine* theWrappedObject, int msec) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QTimer : public QTimer
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QTimer(QObject* parent = 0):QTimer(parent),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QTimer();
|
|
|
|
|
|
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 PythonQtPublicPromoter_QTimer : public QTimer
|
|
|
{ public:
|
|
|
inline void promoted_timerEvent(QTimerEvent* arg__1) { QTimer::timerEvent(arg__1); }
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QTimer : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QTimer* new_QTimer(QObject* parent = 0);
|
|
|
void delete_QTimer(QTimer* obj) { delete obj; }
|
|
|
int interval(QTimer* theWrappedObject) const;
|
|
|
bool isActive(QTimer* theWrappedObject) const;
|
|
|
bool isSingleShot(QTimer* theWrappedObject) const;
|
|
|
void setInterval(QTimer* theWrappedObject, int msec);
|
|
|
void setSingleShot(QTimer* theWrappedObject, bool singleShot);
|
|
|
void static_QTimer_singleShot(int msec, QObject* receiver, const char* member);
|
|
|
void timerEvent(QTimer* theWrappedObject, QTimerEvent* arg__1);
|
|
|
int timerId(QTimer* theWrappedObject) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QTimerEvent : public QTimerEvent
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QTimerEvent(int timerId):QTimerEvent(timerId),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QTimerEvent();
|
|
|
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QTimerEvent : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QTimerEvent* new_QTimerEvent(int timerId);
|
|
|
void delete_QTimerEvent(QTimerEvent* obj) { delete obj; }
|
|
|
int timerId(QTimerEvent* theWrappedObject) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QTranslator : public QTranslator
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QTranslator(QObject* parent = 0):QTranslator(parent),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QTranslator();
|
|
|
|
|
|
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 bool isEmpty() const;
|
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
|
virtual QString translate(const char* context, const char* sourceText, const char* disambiguation = 0) const;
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtPublicPromoter_QTranslator : public QTranslator
|
|
|
{ public:
|
|
|
inline bool promoted_isEmpty() const { return QTranslator::isEmpty(); }
|
|
|
inline QString promoted_translate(const char* context, const char* sourceText, const char* disambiguation = 0) const { return QTranslator::translate(context, sourceText, disambiguation); }
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QTranslator : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QTranslator* new_QTranslator(QObject* parent = 0);
|
|
|
void delete_QTranslator(QTranslator* obj) { delete obj; }
|
|
|
bool isEmpty(QTranslator* theWrappedObject) const;
|
|
|
bool load(QTranslator* theWrappedObject, const QLocale& locale, const QString& filename, const QString& prefix = QString(), const QString& directory = QString(), const QString& suffix = QString());
|
|
|
bool load(QTranslator* theWrappedObject, const QString& filename, const QString& directory = QString(), const QString& search_delimiters = QString(), const QString& suffix = QString());
|
|
|
bool load(QTranslator* theWrappedObject, const uchar* data, int len);
|
|
|
QString translate(QTranslator* theWrappedObject, const char* context, const char* sourceText, const char* disambiguation = 0) const;
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QUuid : public QUuid
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QUuid():QUuid(),_wrapper(NULL) {};
|
|
|
PythonQtShell_QUuid(const QByteArray& arg__1):QUuid(arg__1),_wrapper(NULL) {};
|
|
|
PythonQtShell_QUuid(const QString& arg__1):QUuid(arg__1),_wrapper(NULL) {};
|
|
|
PythonQtShell_QUuid(uint l, ushort w1, ushort w2, uchar b1, uchar b2, uchar b3, uchar b4, uchar b5, uchar b6, uchar b7, uchar b8):QUuid(l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QUuid();
|
|
|
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QUuid : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
Q_ENUMS(Variant Version )
|
|
|
enum Variant{
|
|
|
VarUnknown = QUuid::VarUnknown, NCS = QUuid::NCS, DCE = QUuid::DCE, Microsoft = QUuid::Microsoft, Reserved = QUuid::Reserved};
|
|
|
enum Version{
|
|
|
VerUnknown = QUuid::VerUnknown, Time = QUuid::Time, EmbeddedPOSIX = QUuid::EmbeddedPOSIX, Name = QUuid::Name, Random = QUuid::Random};
|
|
|
public slots:
|
|
|
QUuid* new_QUuid();
|
|
|
QUuid* new_QUuid(const QByteArray& arg__1);
|
|
|
QUuid* new_QUuid(const QString& arg__1);
|
|
|
QUuid* new_QUuid(uint l, ushort w1, ushort w2, uchar b1, uchar b2, uchar b3, uchar b4, uchar b5, uchar b6, uchar b7, uchar b8);
|
|
|
QUuid* new_QUuid(const QUuid& other) {
|
|
|
PythonQtShell_QUuid* a = new PythonQtShell_QUuid();
|
|
|
*((QUuid*)a) = other;
|
|
|
return a; }
|
|
|
void delete_QUuid(QUuid* obj) { delete obj; }
|
|
|
QUuid static_QUuid_createUuid();
|
|
|
QUuid static_QUuid_fromRfc4122(const QByteArray& arg__1);
|
|
|
bool isNull(QUuid* theWrappedObject) const;
|
|
|
bool __ne__(QUuid* theWrappedObject, const QUuid& orig) const;
|
|
|
bool __lt__(QUuid* theWrappedObject, const QUuid& other) const;
|
|
|
void writeTo(QUuid* theWrappedObject, QDataStream& arg__1);
|
|
|
bool __eq__(QUuid* theWrappedObject, const QUuid& orig) const;
|
|
|
bool __gt__(QUuid* theWrappedObject, const QUuid& other) const;
|
|
|
void readFrom(QUuid* theWrappedObject, QDataStream& arg__1);
|
|
|
QByteArray toByteArray(QUuid* theWrappedObject) const;
|
|
|
QByteArray toRfc4122(QUuid* theWrappedObject) const;
|
|
|
QString toString(QUuid* theWrappedObject) const;
|
|
|
QUuid::Variant variant(QUuid* theWrappedObject) const;
|
|
|
QUuid::Version version(QUuid* theWrappedObject) const;
|
|
|
QString py_toString(QUuid*);
|
|
|
bool __nonzero__(QUuid* obj) { return !obj->isNull(); }
|
|
|
void py_set_data1(QUuid* theWrappedObject, uint data1){ theWrappedObject->data1 = data1; }
|
|
|
uint py_get_data1(QUuid* theWrappedObject){ return theWrappedObject->data1; }
|
|
|
void py_set_data2(QUuid* theWrappedObject, ushort data2){ theWrappedObject->data2 = data2; }
|
|
|
ushort py_get_data2(QUuid* theWrappedObject){ return theWrappedObject->data2; }
|
|
|
void py_set_data3(QUuid* theWrappedObject, ushort data3){ theWrappedObject->data3 = data3; }
|
|
|
ushort py_get_data3(QUuid* theWrappedObject){ return theWrappedObject->data3; }
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QVariantAnimation : public QVariantAnimation
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QVariantAnimation(QObject* parent = 0):QVariantAnimation(parent),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QVariantAnimation();
|
|
|
|
|
|
virtual void childEvent(QChildEvent* arg__1);
|
|
|
virtual void customEvent(QEvent* arg__1);
|
|
|
virtual int duration() const;
|
|
|
virtual bool event(QEvent* event);
|
|
|
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2);
|
|
|
virtual QVariant interpolated(const QVariant& from, const QVariant& to, qreal progress) const;
|
|
|
virtual void timerEvent(QTimerEvent* arg__1);
|
|
|
virtual void updateCurrentTime(int arg__1);
|
|
|
virtual void updateCurrentValue(const QVariant& value);
|
|
|
virtual void updateDirection(QAbstractAnimation::Direction direction);
|
|
|
virtual void updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState);
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtPublicPromoter_QVariantAnimation : public QVariantAnimation
|
|
|
{ public:
|
|
|
inline int promoted_duration() const { return QVariantAnimation::duration(); }
|
|
|
inline bool promoted_event(QEvent* event) { return QVariantAnimation::event(event); }
|
|
|
inline QVariant promoted_interpolated(const QVariant& from, const QVariant& to, qreal progress) const { return QVariantAnimation::interpolated(from, to, progress); }
|
|
|
inline void promoted_updateCurrentTime(int arg__1) { QVariantAnimation::updateCurrentTime(arg__1); }
|
|
|
inline void promoted_updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState) { QVariantAnimation::updateState(newState, oldState); }
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QVariantAnimation : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QVariantAnimation* new_QVariantAnimation(QObject* parent = 0);
|
|
|
void delete_QVariantAnimation(QVariantAnimation* obj) { delete obj; }
|
|
|
QVariant currentValue(QVariantAnimation* theWrappedObject) const;
|
|
|
int duration(QVariantAnimation* theWrappedObject) const;
|
|
|
QEasingCurve easingCurve(QVariantAnimation* theWrappedObject) const;
|
|
|
QVariant endValue(QVariantAnimation* theWrappedObject) const;
|
|
|
bool event(QVariantAnimation* theWrappedObject, QEvent* event);
|
|
|
QVariant interpolated(QVariantAnimation* theWrappedObject, const QVariant& from, const QVariant& to, qreal progress) const;
|
|
|
QVariant keyValueAt(QVariantAnimation* theWrappedObject, qreal step) const;
|
|
|
QVector<QPair<qreal , QVariant > > keyValues(QVariantAnimation* theWrappedObject) const;
|
|
|
void setDuration(QVariantAnimation* theWrappedObject, int msecs);
|
|
|
void setEasingCurve(QVariantAnimation* theWrappedObject, const QEasingCurve& easing);
|
|
|
void setEndValue(QVariantAnimation* theWrappedObject, const QVariant& value);
|
|
|
void setKeyValueAt(QVariantAnimation* theWrappedObject, qreal step, const QVariant& value);
|
|
|
void setKeyValues(QVariantAnimation* theWrappedObject, const QVector<QPair<qreal , QVariant > >& values);
|
|
|
void setStartValue(QVariantAnimation* theWrappedObject, const QVariant& value);
|
|
|
QVariant startValue(QVariantAnimation* theWrappedObject) const;
|
|
|
void updateCurrentTime(QVariantAnimation* theWrappedObject, int arg__1);
|
|
|
void updateState(QVariantAnimation* theWrappedObject, QAbstractAnimation::State newState, QAbstractAnimation::State oldState);
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtWrapper_QWaitCondition : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QWaitCondition* new_QWaitCondition();
|
|
|
void delete_QWaitCondition(QWaitCondition* obj) { delete obj; }
|
|
|
bool wait(QWaitCondition* theWrappedObject, QMutex* mutex, unsigned long time = ULONG_MAX);
|
|
|
bool wait(QWaitCondition* theWrappedObject, QReadWriteLock* readWriteLock, unsigned long time = ULONG_MAX);
|
|
|
void wakeAll(QWaitCondition* theWrappedObject);
|
|
|
void wakeOne(QWaitCondition* theWrappedObject);
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtShell_QXmlStreamEntityResolver : public QXmlStreamEntityResolver
|
|
|
{
|
|
|
public:
|
|
|
PythonQtShell_QXmlStreamEntityResolver():QXmlStreamEntityResolver(),_wrapper(NULL) {};
|
|
|
|
|
|
~PythonQtShell_QXmlStreamEntityResolver();
|
|
|
|
|
|
virtual QString resolveEntity(const QString& publicId, const QString& systemId);
|
|
|
virtual QString resolveUndeclaredEntity(const QString& name);
|
|
|
|
|
|
PythonQtInstanceWrapper* _wrapper;
|
|
|
};
|
|
|
|
|
|
class PythonQtPublicPromoter_QXmlStreamEntityResolver : public QXmlStreamEntityResolver
|
|
|
{ public:
|
|
|
inline QString promoted_resolveEntity(const QString& publicId, const QString& systemId) { return QXmlStreamEntityResolver::resolveEntity(publicId, systemId); }
|
|
|
inline QString promoted_resolveUndeclaredEntity(const QString& name) { return QXmlStreamEntityResolver::resolveUndeclaredEntity(name); }
|
|
|
};
|
|
|
|
|
|
class PythonQtWrapper_QXmlStreamEntityResolver : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
public slots:
|
|
|
QXmlStreamEntityResolver* new_QXmlStreamEntityResolver();
|
|
|
void delete_QXmlStreamEntityResolver(QXmlStreamEntityResolver* obj) { delete obj; }
|
|
|
QString resolveEntity(QXmlStreamEntityResolver* theWrappedObject, const QString& publicId, const QString& systemId);
|
|
|
QString resolveUndeclaredEntity(QXmlStreamEntityResolver* theWrappedObject, const QString& name);
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class PythonQtWrapper_QtConcurrent : public QObject
|
|
|
{ Q_OBJECT
|
|
|
public:
|
|
|
Q_ENUMS(ReduceOption ThreadFunctionResult )
|
|
|
Q_FLAGS(ReduceOptions )
|
|
|
enum ReduceOption{
|
|
|
UnorderedReduce = QtConcurrent::UnorderedReduce, OrderedReduce = QtConcurrent::OrderedReduce, SequentialReduce = QtConcurrent::SequentialReduce};
|
|
|
enum ThreadFunctionResult{
|
|
|
ThrottleThread = QtConcurrent::ThrottleThread, ThreadFinished = QtConcurrent::ThreadFinished};
|
|
|
Q_DECLARE_FLAGS(ReduceOptions, ReduceOption)
|
|
|
public slots:
|
|
|
};
|
|
|
|
|
|
|
|
|
|