com_trolltech_qt_core1.h
1300 lines
| 59.1 KiB
| text/x-c
|
CLexer
florianlink
|
r99 | #include <PythonQt.h> | ||
#include <QObject> | ||||
florianlink
|
r110 | #include <QStringList> | ||
florianlink
|
r99 | #include <QTextCodec> | ||
florianlink
|
r110 | #include <QVarLengthArray> | ||
florianlink
|
r99 | #include <QVariant> | ||
florianlink
|
r110 | #include <qabstractanimation.h> | ||
#include <qabstractstate.h> | ||||
#include <qabstracttransition.h> | ||||
#include <qanimationgroup.h> | ||||
florianlink
|
r99 | #include <qbytearray.h> | ||
#include <qcoreevent.h> | ||||
florianlink
|
r110 | #include <qeasingcurve.h> | ||
florianlink
|
r99 | #include <qfile.h> | ||
#include <qiodevice.h> | ||||
#include <qlist.h> | ||||
florianlink
|
r110 | #include <qlocale.h> | ||
florianlink
|
r99 | #include <qmutex.h> | ||
#include <qobject.h> | ||||
florianlink
|
r110 | #include <qpair.h> | ||
#include <qparallelanimationgroup.h> | ||||
#include <qpauseanimation.h> | ||||
#include <qprocess.h> | ||||
#include <qpropertyanimation.h> | ||||
florianlink
|
r99 | #include <qreadwritelock.h> | ||
#include <qrunnable.h> | ||||
florianlink
|
r110 | #include <qsemaphore.h> | ||
#include <qsequentialanimationgroup.h> | ||||
#include <qsettings.h> | ||||
florianlink
|
r99 | #include <qsignalmapper.h> | ||
florianlink
|
r110 | #include <qsignaltransition.h> | ||
florianlink
|
r99 | #include <qsocketnotifier.h> | ||
florianlink
|
r110 | #include <qstate.h> | ||
#include <qstatemachine.h> | ||||
florianlink
|
r99 | #include <qstringlist.h> | ||
#include <qstringmatcher.h> | ||||
#include <qsystemsemaphore.h> | ||||
#include <qtemporaryfile.h> | ||||
#include <qtextboundaryfinder.h> | ||||
#include <qtextcodec.h> | ||||
#include <qtextstream.h> | ||||
#include <qthreadpool.h> | ||||
#include <qtimeline.h> | ||||
florianlink
|
r128 | #include <qtimer.h> | ||
florianlink
|
r99 | #include <qvector.h> | ||
florianlink
|
r110 | |||
class PythonQtWrapper_QMutex : public QObject | ||||
{ Q_OBJECT | ||||
public: | ||||
Q_ENUMS(RecursionMode ) | ||||
enum RecursionMode{ | ||||
NonRecursive = QMutex::NonRecursive, Recursive = QMutex::Recursive}; | ||||
public slots: | ||||
QMutex* new_QMutex(QMutex::RecursionMode mode = QMutex::NonRecursive); | ||||
void delete_QMutex(QMutex* obj) { delete obj; } | ||||
void lock(QMutex* theWrappedObject); | ||||
florianlink
|
r128 | bool tryLock(QMutex* theWrappedObject); | ||
bool tryLock(QMutex* theWrappedObject, int timeout); | ||||
void unlock(QMutex* theWrappedObject); | ||||
florianlink
|
r110 | }; | ||
class PythonQtShell_QObject : public QObject | ||||
{ | ||||
public: | ||||
PythonQtShell_QObject(QObject* parent = 0):QObject(parent),_wrapper(NULL) {}; | ||||
florianlink
|
r128 | virtual void childEvent(QChildEvent* arg__1); | ||
florianlink
|
r110 | virtual void customEvent(QEvent* arg__1); | ||
virtual bool event(QEvent* arg__1); | ||||
florianlink
|
r120 | virtual bool eventFilter(QObject* arg__1, QEvent* arg__2); | ||
florianlink
|
r128 | virtual void timerEvent(QTimerEvent* arg__1); | ||
florianlink
|
r110 | |||
PythonQtInstanceWrapper* _wrapper; | ||||
}; | ||||
class PythonQtPublicPromoter_QObject : public QObject | ||||
{ public: | ||||
florianlink
|
r128 | inline void promoted_childEvent(QChildEvent* arg__1) { QObject::childEvent(arg__1); } | ||
florianlink
|
r110 | inline void promoted_customEvent(QEvent* arg__1) { QObject::customEvent(arg__1); } | ||
inline bool promoted_event(QEvent* arg__1) { return QObject::event(arg__1); } | ||||
florianlink
|
r120 | inline bool promoted_eventFilter(QObject* arg__1, QEvent* arg__2) { return QObject::eventFilter(arg__1, arg__2); } | ||
florianlink
|
r128 | inline void promoted_timerEvent(QTimerEvent* arg__1) { QObject::timerEvent(arg__1); } | ||
florianlink
|
r110 | }; | ||
class PythonQtWrapper_QObject : public QObject | ||||
{ Q_OBJECT | ||||
public: | ||||
public slots: | ||||
QObject* new_QObject(QObject* parent = 0); | ||||
void delete_QObject(QObject* obj) { delete obj; } | ||||
florianlink
|
r128 | bool blockSignals(QObject* theWrappedObject, bool b); | ||
void childEvent(QObject* theWrappedObject, QChildEvent* arg__1); | ||||
const QList<QObject* >* children(QObject* theWrappedObject) const; | ||||
void customEvent(QObject* theWrappedObject, QEvent* arg__1); | ||||
florianlink
|
r110 | void dumpObjectInfo(QObject* theWrappedObject); | ||
florianlink
|
r120 | void dumpObjectTree(QObject* theWrappedObject); | ||
florianlink
|
r128 | QList<QByteArray > dynamicPropertyNames(QObject* theWrappedObject) const; | ||
bool event(QObject* theWrappedObject, QEvent* arg__1); | ||||
bool eventFilter(QObject* theWrappedObject, QObject* arg__1, QEvent* arg__2); | ||||
void installEventFilter(QObject* theWrappedObject, QObject* arg__1); | ||||
bool isWidgetType(QObject* theWrappedObject) const; | ||||
florianlink
|
r110 | void killTimer(QObject* theWrappedObject, int id); | ||
florianlink
|
r128 | void moveToThread(QObject* theWrappedObject, QThread* thread); | ||
QString objectName(QObject* theWrappedObject) const; | ||||
QObject* parent(QObject* theWrappedObject) const; | ||||
QVariant property(QObject* theWrappedObject, const char* name) const; | ||||
void removeEventFilter(QObject* theWrappedObject, QObject* arg__1); | ||||
florianlink
|
r110 | void setObjectName(QObject* theWrappedObject, const QString& name); | ||
florianlink
|
r117 | void setParent(QObject* theWrappedObject, QObject* arg__1); | ||
florianlink
|
r128 | bool setProperty(QObject* theWrappedObject, const char* name, const QVariant& value); | ||
bool signalsBlocked(QObject* theWrappedObject) const; | ||||
florianlink
|
r110 | int startTimer(QObject* theWrappedObject, int interval); | ||
florianlink
|
r128 | QThread* thread(QObject* theWrappedObject) const; | ||
void timerEvent(QObject* theWrappedObject, QTimerEvent* arg__1); | ||||
florianlink
|
r110 | }; | ||
class PythonQtShell_QParallelAnimationGroup : public QParallelAnimationGroup | ||||
{ | ||||
public: | ||||
PythonQtShell_QParallelAnimationGroup(QObject* parent = 0):QParallelAnimationGroup(parent),_wrapper(NULL) {}; | ||||
florianlink
|
r128 | virtual void childEvent(QChildEvent* arg__1); | ||
virtual void customEvent(QEvent* arg__1); | ||||
florianlink
|
r120 | virtual int duration() const; | ||
florianlink
|
r110 | virtual bool event(QEvent* event); | ||
florianlink
|
r120 | virtual bool eventFilter(QObject* arg__1, QEvent* arg__2); | ||
virtual void timerEvent(QTimerEvent* arg__1); | ||||
florianlink
|
r128 | virtual void updateCurrentTime(int currentTime); | ||
virtual void updateDirection(QAbstractAnimation::Direction direction); | ||||
virtual void updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState); | ||||
florianlink
|
r110 | |||
PythonQtInstanceWrapper* _wrapper; | ||||
}; | ||||
class PythonQtPublicPromoter_QParallelAnimationGroup : public QParallelAnimationGroup | ||||
{ public: | ||||
florianlink
|
r120 | inline int promoted_duration() const { return QParallelAnimationGroup::duration(); } | ||
florianlink
|
r110 | inline bool promoted_event(QEvent* event) { return QParallelAnimationGroup::event(event); } | ||
florianlink
|
r128 | inline void promoted_updateCurrentTime(int currentTime) { QParallelAnimationGroup::updateCurrentTime(currentTime); } | ||
inline void promoted_updateDirection(QAbstractAnimation::Direction direction) { QParallelAnimationGroup::updateDirection(direction); } | ||||
inline void promoted_updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState) { QParallelAnimationGroup::updateState(newState, oldState); } | ||||
florianlink
|
r110 | }; | ||
class PythonQtWrapper_QParallelAnimationGroup : public QObject | ||||
{ Q_OBJECT | ||||
public: | ||||
public slots: | ||||
QParallelAnimationGroup* new_QParallelAnimationGroup(QObject* parent = 0); | ||||
void delete_QParallelAnimationGroup(QParallelAnimationGroup* obj) { delete obj; } | ||||
florianlink
|
r120 | int duration(QParallelAnimationGroup* theWrappedObject) const; | ||
florianlink
|
r110 | bool event(QParallelAnimationGroup* theWrappedObject, QEvent* event); | ||
florianlink
|
r128 | void updateCurrentTime(QParallelAnimationGroup* theWrappedObject, int currentTime); | ||
void updateDirection(QParallelAnimationGroup* theWrappedObject, QAbstractAnimation::Direction direction); | ||||
void updateState(QParallelAnimationGroup* theWrappedObject, QAbstractAnimation::State newState, QAbstractAnimation::State oldState); | ||||
florianlink
|
r110 | }; | ||
class PythonQtShell_QPauseAnimation : public QPauseAnimation | ||||
{ | ||||
public: | ||||
PythonQtShell_QPauseAnimation(QObject* parent = 0):QPauseAnimation(parent),_wrapper(NULL) {}; | ||||
PythonQtShell_QPauseAnimation(int msecs, QObject* parent = 0):QPauseAnimation(msecs, parent),_wrapper(NULL) {}; | ||||
florianlink
|
r128 | virtual void childEvent(QChildEvent* arg__1); | ||
virtual void customEvent(QEvent* arg__1); | ||||
florianlink
|
r110 | virtual int duration() const; | ||
virtual bool event(QEvent* e); | ||||
florianlink
|
r120 | virtual bool eventFilter(QObject* arg__1, QEvent* arg__2); | ||
virtual void timerEvent(QTimerEvent* arg__1); | ||||
florianlink
|
r128 | virtual void updateCurrentTime(int arg__1); | ||
virtual void updateDirection(QAbstractAnimation::Direction direction); | ||||
virtual void updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState); | ||||
florianlink
|
r110 | |||
PythonQtInstanceWrapper* _wrapper; | ||||
}; | ||||
class PythonQtPublicPromoter_QPauseAnimation : public QPauseAnimation | ||||
{ public: | ||||
inline int promoted_duration() const { return QPauseAnimation::duration(); } | ||||
inline bool promoted_event(QEvent* e) { return QPauseAnimation::event(e); } | ||||
florianlink
|
r128 | inline void promoted_updateCurrentTime(int arg__1) { QPauseAnimation::updateCurrentTime(arg__1); } | ||
florianlink
|
r110 | }; | ||
class PythonQtWrapper_QPauseAnimation : public QObject | ||||
{ Q_OBJECT | ||||
public: | ||||
public slots: | ||||
QPauseAnimation* new_QPauseAnimation(QObject* parent = 0); | ||||
QPauseAnimation* new_QPauseAnimation(int msecs, QObject* parent = 0); | ||||
void delete_QPauseAnimation(QPauseAnimation* obj) { delete obj; } | ||||
int duration(QPauseAnimation* theWrappedObject) const; | ||||
bool event(QPauseAnimation* theWrappedObject, QEvent* e); | ||||
void setDuration(QPauseAnimation* theWrappedObject, int msecs); | ||||
florianlink
|
r128 | void updateCurrentTime(QPauseAnimation* theWrappedObject, int arg__1); | ||
florianlink
|
r110 | }; | ||
class PythonQtShell_QProcess : public QProcess | ||||
{ | ||||
public: | ||||
PythonQtShell_QProcess(QObject* parent = 0):QProcess(parent),_wrapper(NULL) {}; | ||||
florianlink
|
r128 | virtual bool atEnd() const; | ||
florianlink
|
r110 | virtual qint64 bytesAvailable() const; | ||
florianlink
|
r128 | virtual qint64 bytesToWrite() const; | ||
virtual bool canReadLine() const; | ||||
virtual void childEvent(QChildEvent* arg__1); | ||||
florianlink
|
r110 | 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); | ||||
florianlink
|
r110 | virtual bool isSequential() const; | ||
florianlink
|
r120 | virtual bool open(QIODevice::OpenMode mode); | ||
florianlink
|
r128 | virtual qint64 pos() const; | ||
virtual qint64 readData(char* data, qint64 maxlen); | ||||
florianlink
|
r110 | virtual qint64 readLineData(char* data, qint64 maxlen); | ||
florianlink
|
r128 | virtual bool reset(); | ||
virtual bool seek(qint64 pos); | ||||
virtual void setupChildProcess(); | ||||
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
|
r110 | |||
PythonQtInstanceWrapper* _wrapper; | ||||
}; | ||||
class PythonQtPublicPromoter_QProcess : public QProcess | ||||
{ public: | ||||
florianlink
|
r128 | inline bool promoted_atEnd() const { return QProcess::atEnd(); } | ||
florianlink
|
r110 | inline qint64 promoted_bytesAvailable() const { return QProcess::bytesAvailable(); } | ||
florianlink
|
r128 | inline qint64 promoted_bytesToWrite() const { return QProcess::bytesToWrite(); } | ||
inline bool promoted_canReadLine() const { return QProcess::canReadLine(); } | ||||
florianlink
|
r110 | inline void promoted_close() { QProcess::close(); } | ||
inline bool promoted_isSequential() const { return QProcess::isSequential(); } | ||||
inline qint64 promoted_readData(char* data, qint64 maxlen) { return QProcess::readData(data, maxlen); } | ||||
florianlink
|
r128 | inline void promoted_setupChildProcess() { QProcess::setupChildProcess(); } | ||
florianlink
|
r120 | inline bool promoted_waitForBytesWritten(int msecs = 30000) { return QProcess::waitForBytesWritten(msecs); } | ||
florianlink
|
r128 | inline bool promoted_waitForReadyRead(int msecs = 30000) { return QProcess::waitForReadyRead(msecs); } | ||
florianlink
|
r120 | inline qint64 promoted_writeData(const char* data, qint64 len) { return QProcess::writeData(data, len); } | ||
florianlink
|
r110 | }; | ||
class PythonQtWrapper_QProcess : public QObject | ||||
{ Q_OBJECT | ||||
public: | ||||
Q_ENUMS(ProcessError ProcessChannelMode ProcessChannel ProcessState ExitStatus ) | ||||
enum ProcessError{ | ||||
FailedToStart = QProcess::FailedToStart, Crashed = QProcess::Crashed, Timedout = QProcess::Timedout, ReadError = QProcess::ReadError, WriteError = QProcess::WriteError, UnknownError = QProcess::UnknownError}; | ||||
enum ProcessChannelMode{ | ||||
SeparateChannels = QProcess::SeparateChannels, MergedChannels = QProcess::MergedChannels, ForwardedChannels = QProcess::ForwardedChannels}; | ||||
enum ProcessChannel{ | ||||
StandardOutput = QProcess::StandardOutput, StandardError = QProcess::StandardError}; | ||||
enum ProcessState{ | ||||
NotRunning = QProcess::NotRunning, Starting = QProcess::Starting, Running = QProcess::Running}; | ||||
enum ExitStatus{ | ||||
NormalExit = QProcess::NormalExit, CrashExit = QProcess::CrashExit}; | ||||
public slots: | ||||
QProcess* new_QProcess(QObject* parent = 0); | ||||
void delete_QProcess(QProcess* obj) { delete obj; } | ||||
florianlink
|
r128 | bool atEnd(QProcess* theWrappedObject) const; | ||
qint64 bytesAvailable(QProcess* theWrappedObject) const; | ||||
qint64 bytesToWrite(QProcess* theWrappedObject) const; | ||||
florianlink
|
r120 | bool canReadLine(QProcess* theWrappedObject) const; | ||
florianlink
|
r128 | void close(QProcess* theWrappedObject); | ||
void closeReadChannel(QProcess* theWrappedObject, QProcess::ProcessChannel channel); | ||||
void closeWriteChannel(QProcess* theWrappedObject); | ||||
florianlink
|
r120 | QStringList environment(QProcess* theWrappedObject) const; | ||
florianlink
|
r110 | QProcess::ProcessError error(QProcess* theWrappedObject) const; | ||
florianlink
|
r120 | int static_QProcess_execute(const QString& program); | ||
florianlink
|
r128 | int static_QProcess_execute(const QString& program, const QStringList& arguments); | ||
int exitCode(QProcess* theWrappedObject) const; | ||||
QProcess::ExitStatus exitStatus(QProcess* theWrappedObject) const; | ||||
bool isSequential(QProcess* theWrappedObject) const; | ||||
QProcess::ProcessChannelMode processChannelMode(QProcess* theWrappedObject) const; | ||||
florianlink
|
r110 | QProcessEnvironment processEnvironment(QProcess* theWrappedObject) const; | ||
florianlink
|
r128 | QByteArray readAllStandardError(QProcess* theWrappedObject); | ||
QByteArray readAllStandardOutput(QProcess* theWrappedObject); | ||||
QProcess::ProcessChannel readChannel(QProcess* theWrappedObject) const; | ||||
qint64 readData(QProcess* theWrappedObject, char* data, qint64 maxlen); | ||||
void setEnvironment(QProcess* theWrappedObject, const QStringList& environment); | ||||
void setProcessChannelMode(QProcess* theWrappedObject, QProcess::ProcessChannelMode mode); | ||||
void setProcessEnvironment(QProcess* theWrappedObject, const QProcessEnvironment& environment); | ||||
void setReadChannel(QProcess* theWrappedObject, QProcess::ProcessChannel channel); | ||||
void setStandardErrorFile(QProcess* theWrappedObject, const QString& fileName, QIODevice::OpenMode mode = QIODevice::Truncate); | ||||
void setStandardInputFile(QProcess* theWrappedObject, const QString& fileName); | ||||
void setStandardOutputFile(QProcess* theWrappedObject, const QString& fileName, QIODevice::OpenMode mode = QIODevice::Truncate); | ||||
void setStandardOutputProcess(QProcess* theWrappedObject, QProcess* destination); | ||||
florianlink
|
r110 | void setWorkingDirectory(QProcess* theWrappedObject, const QString& dir); | ||
florianlink
|
r128 | void setupChildProcess(QProcess* theWrappedObject); | ||
florianlink
|
r110 | void start(QProcess* theWrappedObject, const QString& program, QIODevice::OpenMode mode = QIODevice::ReadWrite); | ||
void start(QProcess* theWrappedObject, const QString& program, const QStringList& arguments, QIODevice::OpenMode mode = QIODevice::ReadWrite); | ||||
florianlink
|
r128 | bool static_QProcess_startDetached(const QString& program); | ||
bool static_QProcess_startDetached(const QString& program, const QStringList& arguments); | ||||
bool static_QProcess_startDetached(const QString& program, const QStringList& arguments, const QString& workingDirectory, qint64* pid = 0); | ||||
florianlink
|
r120 | QProcess::ProcessState state(QProcess* theWrappedObject) const; | ||
florianlink
|
r110 | QStringList static_QProcess_systemEnvironment(); | ||
florianlink
|
r120 | bool waitForBytesWritten(QProcess* theWrappedObject, int msecs = 30000); | ||
florianlink
|
r128 | bool waitForFinished(QProcess* theWrappedObject, int msecs = 30000); | ||
bool waitForReadyRead(QProcess* theWrappedObject, int msecs = 30000); | ||||
bool waitForStarted(QProcess* theWrappedObject, int msecs = 30000); | ||||
QString workingDirectory(QProcess* theWrappedObject) const; | ||||
florianlink
|
r120 | qint64 writeData(QProcess* theWrappedObject, const char* data, qint64 len); | ||
florianlink
|
r110 | }; | ||
class PythonQtWrapper_QProcessEnvironment : public QObject | ||||
{ Q_OBJECT | ||||
public: | ||||
public slots: | ||||
QProcessEnvironment* new_QProcessEnvironment(); | ||||
QProcessEnvironment* new_QProcessEnvironment(const QProcessEnvironment& other); | ||||
void delete_QProcessEnvironment(QProcessEnvironment* obj) { delete obj; } | ||||
florianlink
|
r120 | void clear(QProcessEnvironment* theWrappedObject); | ||
florianlink
|
r128 | bool contains(QProcessEnvironment* theWrappedObject, const QString& name) const; | ||
void insert(QProcessEnvironment* theWrappedObject, const QString& name, const QString& value); | ||||
bool isEmpty(QProcessEnvironment* theWrappedObject) const; | ||||
florianlink
|
r120 | bool __ne__(QProcessEnvironment* theWrappedObject, const QProcessEnvironment& other) const; | ||
florianlink
|
r128 | QProcessEnvironment* operator_assign(QProcessEnvironment* theWrappedObject, const QProcessEnvironment& other); | ||
bool __eq__(QProcessEnvironment* theWrappedObject, const QProcessEnvironment& other) const; | ||||
florianlink
|
r110 | void remove(QProcessEnvironment* theWrappedObject, const QString& name); | ||
QProcessEnvironment static_QProcessEnvironment_systemEnvironment(); | ||||
florianlink
|
r128 | QStringList toStringList(QProcessEnvironment* theWrappedObject) const; | ||
florianlink
|
r110 | QString value(QProcessEnvironment* theWrappedObject, const QString& name, const QString& defaultValue = QString()) const; | ||
}; | ||||
class PythonQtShell_QPropertyAnimation : public QPropertyAnimation | ||||
{ | ||||
public: | ||||
PythonQtShell_QPropertyAnimation(QObject* parent = 0):QPropertyAnimation(parent),_wrapper(NULL) {}; | ||||
PythonQtShell_QPropertyAnimation(QObject* target, const QByteArray& propertyName, QObject* parent = 0):QPropertyAnimation(target, propertyName, parent),_wrapper(NULL) {}; | ||||
florianlink
|
r128 | virtual void childEvent(QChildEvent* arg__1); | ||
virtual void customEvent(QEvent* arg__1); | ||||
florianlink
|
r110 | virtual int duration() const; | ||
florianlink
|
r128 | virtual bool event(QEvent* event); | ||
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2); | ||||
florianlink
|
r110 | virtual QVariant interpolated(const QVariant& from, const QVariant& to, qreal progress) const; | ||
florianlink
|
r128 | virtual void timerEvent(QTimerEvent* arg__1); | ||
florianlink
|
r110 | virtual void updateCurrentTime(int arg__1); | ||
florianlink
|
r128 | virtual void updateCurrentValue(const QVariant& value); | ||
florianlink
|
r110 | virtual void updateDirection(QAbstractAnimation::Direction direction); | ||
florianlink
|
r128 | virtual void updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState); | ||
florianlink
|
r110 | |||
PythonQtInstanceWrapper* _wrapper; | ||||
}; | ||||
class PythonQtPublicPromoter_QPropertyAnimation : public QPropertyAnimation | ||||
{ public: | ||||
inline bool promoted_event(QEvent* event) { return QPropertyAnimation::event(event); } | ||||
inline void promoted_updateCurrentValue(const QVariant& value) { QPropertyAnimation::updateCurrentValue(value); } | ||||
florianlink
|
r128 | inline void promoted_updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState) { QPropertyAnimation::updateState(newState, oldState); } | ||
florianlink
|
r110 | }; | ||
class PythonQtWrapper_QPropertyAnimation : public QObject | ||||
{ Q_OBJECT | ||||
public: | ||||
public slots: | ||||
QPropertyAnimation* new_QPropertyAnimation(QObject* parent = 0); | ||||
QPropertyAnimation* new_QPropertyAnimation(QObject* target, const QByteArray& propertyName, QObject* parent = 0); | ||||
void delete_QPropertyAnimation(QPropertyAnimation* obj) { delete obj; } | ||||
bool event(QPropertyAnimation* theWrappedObject, QEvent* event); | ||||
florianlink
|
r128 | QByteArray propertyName(QPropertyAnimation* theWrappedObject) const; | ||
florianlink
|
r110 | void setPropertyName(QPropertyAnimation* theWrappedObject, const QByteArray& propertyName); | ||
void setTargetObject(QPropertyAnimation* theWrappedObject, QObject* target); | ||||
florianlink
|
r128 | QObject* targetObject(QPropertyAnimation* theWrappedObject) const; | ||
void updateCurrentValue(QPropertyAnimation* theWrappedObject, const QVariant& value); | ||||
void updateState(QPropertyAnimation* theWrappedObject, QAbstractAnimation::State newState, QAbstractAnimation::State oldState); | ||||
florianlink
|
r110 | }; | ||
class PythonQtWrapper_QReadWriteLock : public QObject | ||||
{ Q_OBJECT | ||||
public: | ||||
Q_ENUMS(RecursionMode ) | ||||
enum RecursionMode{ | ||||
NonRecursive = QReadWriteLock::NonRecursive, Recursive = QReadWriteLock::Recursive}; | ||||
public slots: | ||||
QReadWriteLock* new_QReadWriteLock(); | ||||
QReadWriteLock* new_QReadWriteLock(QReadWriteLock::RecursionMode recursionMode); | ||||
void delete_QReadWriteLock(QReadWriteLock* obj) { delete obj; } | ||||
florianlink
|
r120 | void lockForRead(QReadWriteLock* theWrappedObject); | ||
florianlink
|
r128 | void lockForWrite(QReadWriteLock* theWrappedObject); | ||
florianlink
|
r110 | bool tryLockForRead(QReadWriteLock* theWrappedObject); | ||
florianlink
|
r128 | bool tryLockForRead(QReadWriteLock* theWrappedObject, int timeout); | ||
florianlink
|
r110 | bool tryLockForWrite(QReadWriteLock* theWrappedObject); | ||
florianlink
|
r128 | bool tryLockForWrite(QReadWriteLock* theWrappedObject, int timeout); | ||
void unlock(QReadWriteLock* theWrappedObject); | ||||
florianlink
|
r110 | }; | ||
class PythonQtShell_QRunnable : public QRunnable | ||||
{ | ||||
public: | ||||
PythonQtShell_QRunnable():QRunnable(),_wrapper(NULL) {}; | ||||
virtual void run(); | ||||
PythonQtInstanceWrapper* _wrapper; | ||||
}; | ||||
class PythonQtWrapper_QRunnable : public QObject | ||||
{ Q_OBJECT | ||||
public: | ||||
public slots: | ||||
QRunnable* new_QRunnable(); | ||||
void delete_QRunnable(QRunnable* obj) { delete obj; } | ||||
florianlink
|
r120 | bool autoDelete(QRunnable* theWrappedObject) const; | ||
florianlink
|
r128 | void setAutoDelete(QRunnable* theWrappedObject, bool _autoDelete); | ||
florianlink
|
r110 | }; | ||
class PythonQtWrapper_QSemaphore : public QObject | ||||
{ Q_OBJECT | ||||
public: | ||||
public slots: | ||||
QSemaphore* new_QSemaphore(int n = 0); | ||||
void delete_QSemaphore(QSemaphore* obj) { delete obj; } | ||||
florianlink
|
r120 | void acquire(QSemaphore* theWrappedObject, int n = 1); | ||
int available(QSemaphore* theWrappedObject) const; | ||||
florianlink
|
r128 | void release(QSemaphore* theWrappedObject, int n = 1); | ||
florianlink
|
r110 | bool tryAcquire(QSemaphore* theWrappedObject, int n = 1); | ||
florianlink
|
r128 | bool tryAcquire(QSemaphore* theWrappedObject, int n, int timeout); | ||
florianlink
|
r110 | }; | ||
class PythonQtShell_QSequentialAnimationGroup : public QSequentialAnimationGroup | ||||
{ | ||||
public: | ||||
PythonQtShell_QSequentialAnimationGroup(QObject* parent = 0):QSequentialAnimationGroup(parent),_wrapper(NULL) {}; | ||||
florianlink
|
r128 | virtual void childEvent(QChildEvent* arg__1); | ||
virtual void customEvent(QEvent* arg__1); | ||||
florianlink
|
r110 | virtual int duration() const; | ||
florianlink
|
r120 | virtual bool event(QEvent* event); | ||
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2); | ||||
virtual void timerEvent(QTimerEvent* arg__1); | ||||
florianlink
|
r128 | virtual void updateCurrentTime(int arg__1); | ||
virtual void updateDirection(QAbstractAnimation::Direction direction); | ||||
virtual void updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState); | ||||
florianlink
|
r110 | |||
PythonQtInstanceWrapper* _wrapper; | ||||
}; | ||||
class PythonQtPublicPromoter_QSequentialAnimationGroup : public QSequentialAnimationGroup | ||||
{ public: | ||||
inline int promoted_duration() const { return QSequentialAnimationGroup::duration(); } | ||||
florianlink
|
r128 | inline bool promoted_event(QEvent* event) { return QSequentialAnimationGroup::event(event); } | ||
florianlink
|
r117 | inline void promoted_updateCurrentTime(int arg__1) { QSequentialAnimationGroup::updateCurrentTime(arg__1); } | ||
florianlink
|
r110 | inline void promoted_updateDirection(QAbstractAnimation::Direction direction) { QSequentialAnimationGroup::updateDirection(direction); } | ||
inline void promoted_updateState(QAbstractAnimation::State newState, QAbstractAnimation::State oldState) { QSequentialAnimationGroup::updateState(newState, oldState); } | ||||
}; | ||||
class PythonQtWrapper_QSequentialAnimationGroup : public QObject | ||||
{ Q_OBJECT | ||||
public: | ||||
public slots: | ||||
QSequentialAnimationGroup* new_QSequentialAnimationGroup(QObject* parent = 0); | ||||
void delete_QSequentialAnimationGroup(QSequentialAnimationGroup* obj) { delete obj; } | ||||
florianlink
|
r128 | QPauseAnimation* addPause(QSequentialAnimationGroup* theWrappedObject, int msecs); | ||
florianlink
|
r110 | QAbstractAnimation* currentAnimation(QSequentialAnimationGroup* theWrappedObject) const; | ||
int duration(QSequentialAnimationGroup* theWrappedObject) const; | ||||
florianlink
|
r128 | bool event(QSequentialAnimationGroup* theWrappedObject, QEvent* event); | ||
QPauseAnimation* insertPause(QSequentialAnimationGroup* theWrappedObject, int index, int msecs); | ||||
florianlink
|
r117 | void updateCurrentTime(QSequentialAnimationGroup* theWrappedObject, int arg__1); | ||
florianlink
|
r110 | void updateDirection(QSequentialAnimationGroup* theWrappedObject, QAbstractAnimation::Direction direction); | ||
florianlink
|
r120 | void updateState(QSequentialAnimationGroup* theWrappedObject, QAbstractAnimation::State newState, QAbstractAnimation::State oldState); | ||
florianlink
|
r110 | }; | ||
class PythonQtShell_QSettings : public QSettings | ||||
{ | ||||
public: | ||||
PythonQtShell_QSettings(QObject* parent = 0):QSettings(parent),_wrapper(NULL) {}; | ||||
PythonQtShell_QSettings(QSettings::Format format, QSettings::Scope scope, const QString& organization, const QString& application = QString(), QObject* parent = 0):QSettings(format, scope, organization, application, parent),_wrapper(NULL) {}; | ||||
PythonQtShell_QSettings(QSettings::Scope scope, const QString& organization, const QString& application = QString(), QObject* parent = 0):QSettings(scope, organization, application, parent),_wrapper(NULL) {}; | ||||
PythonQtShell_QSettings(const QString& fileName, QSettings::Format format, QObject* parent = 0):QSettings(fileName, format, parent),_wrapper(NULL) {}; | ||||
PythonQtShell_QSettings(const QString& organization, const QString& application = QString(), QObject* parent = 0):QSettings(organization, application, parent),_wrapper(NULL) {}; | ||||
virtual void childEvent(QChildEvent* arg__1); | ||||
virtual void customEvent(QEvent* arg__1); | ||||
florianlink
|
r128 | virtual bool event(QEvent* event); | ||
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2); | ||||
florianlink
|
r120 | virtual void timerEvent(QTimerEvent* arg__1); | ||
florianlink
|
r110 | |||
PythonQtInstanceWrapper* _wrapper; | ||||
}; | ||||
class PythonQtPublicPromoter_QSettings : public QSettings | ||||
{ public: | ||||
inline bool promoted_event(QEvent* event) { return QSettings::event(event); } | ||||
}; | ||||
class PythonQtWrapper_QSettings : public QObject | ||||
{ Q_OBJECT | ||||
public: | ||||
Q_ENUMS(Format Status Scope ) | ||||
enum Format{ | ||||
NativeFormat = QSettings::NativeFormat, IniFormat = QSettings::IniFormat, InvalidFormat = QSettings::InvalidFormat, CustomFormat1 = QSettings::CustomFormat1, CustomFormat2 = QSettings::CustomFormat2, CustomFormat3 = QSettings::CustomFormat3, CustomFormat4 = QSettings::CustomFormat4, CustomFormat5 = QSettings::CustomFormat5, CustomFormat6 = QSettings::CustomFormat6, CustomFormat7 = QSettings::CustomFormat7, CustomFormat8 = QSettings::CustomFormat8, CustomFormat9 = QSettings::CustomFormat9, CustomFormat10 = QSettings::CustomFormat10, CustomFormat11 = QSettings::CustomFormat11, CustomFormat12 = QSettings::CustomFormat12, CustomFormat13 = QSettings::CustomFormat13, CustomFormat14 = QSettings::CustomFormat14, CustomFormat15 = QSettings::CustomFormat15, CustomFormat16 = QSettings::CustomFormat16}; | ||||
enum Status{ | ||||
NoError = QSettings::NoError, AccessError = QSettings::AccessError, FormatError = QSettings::FormatError}; | ||||
enum Scope{ | ||||
UserScope = QSettings::UserScope, SystemScope = QSettings::SystemScope}; | ||||
public slots: | ||||
QSettings* new_QSettings(QObject* parent = 0); | ||||
QSettings* new_QSettings(QSettings::Format format, QSettings::Scope scope, const QString& organization, const QString& application = QString(), QObject* parent = 0); | ||||
QSettings* new_QSettings(QSettings::Scope scope, const QString& organization, const QString& application = QString(), QObject* parent = 0); | ||||
QSettings* new_QSettings(const QString& fileName, QSettings::Format format, QObject* parent = 0); | ||||
QSettings* new_QSettings(const QString& organization, const QString& application = QString(), QObject* parent = 0); | ||||
void delete_QSettings(QSettings* obj) { delete obj; } | ||||
florianlink
|
r128 | QStringList allKeys(QSettings* theWrappedObject) const; | ||
QString applicationName(QSettings* theWrappedObject) const; | ||||
florianlink
|
r120 | void beginGroup(QSettings* theWrappedObject, const QString& prefix); | ||
florianlink
|
r128 | int beginReadArray(QSettings* theWrappedObject, const QString& prefix); | ||
void beginWriteArray(QSettings* theWrappedObject, const QString& prefix, int size = -1); | ||||
florianlink
|
r120 | QStringList childGroups(QSettings* theWrappedObject) const; | ||
QStringList childKeys(QSettings* theWrappedObject) const; | ||||
florianlink
|
r128 | void clear(QSettings* theWrappedObject); | ||
bool contains(QSettings* theWrappedObject, const QString& key) const; | ||||
florianlink
|
r110 | QSettings::Format static_QSettings_defaultFormat(); | ||
void endArray(QSettings* theWrappedObject); | ||||
florianlink
|
r128 | void endGroup(QSettings* theWrappedObject); | ||
bool event(QSettings* theWrappedObject, QEvent* event); | ||||
bool fallbacksEnabled(QSettings* theWrappedObject) const; | ||||
florianlink
|
r110 | QString fileName(QSettings* theWrappedObject) const; | ||
QSettings::Format format(QSettings* theWrappedObject) const; | ||||
florianlink
|
r128 | QString group(QSettings* theWrappedObject) const; | ||
QTextCodec* iniCodec(QSettings* theWrappedObject) const; | ||||
bool isWritable(QSettings* theWrappedObject) const; | ||||
QString organizationName(QSettings* theWrappedObject) const; | ||||
void remove(QSettings* theWrappedObject, const QString& key); | ||||
florianlink
|
r110 | QSettings::Scope scope(QSettings* theWrappedObject) const; | ||
florianlink
|
r128 | void setArrayIndex(QSettings* theWrappedObject, int i); | ||
void static_QSettings_setDefaultFormat(QSettings::Format format); | ||||
void setFallbacksEnabled(QSettings* theWrappedObject, bool b); | ||||
void setIniCodec(QSettings* theWrappedObject, QTextCodec* codec); | ||||
void setIniCodec(QSettings* theWrappedObject, const char* codecName); | ||||
void static_QSettings_setPath(QSettings::Format format, QSettings::Scope scope, const QString& path); | ||||
florianlink
|
r110 | void setValue(QSettings* theWrappedObject, const QString& key, const QVariant& value); | ||
florianlink
|
r120 | QSettings::Status status(QSettings* theWrappedObject) const; | ||
florianlink
|
r128 | void sync(QSettings* theWrappedObject); | ||
QVariant value(QSettings* theWrappedObject, const QString& key, const QVariant& defaultValue = QVariant()) const; | ||||
florianlink
|
r110 | }; | ||
florianlink
|
r99 | |||
class PythonQtShell_QSignalMapper : public QSignalMapper | ||||
{ | ||||
public: | ||||
PythonQtShell_QSignalMapper(QObject* parent = 0):QSignalMapper(parent),_wrapper(NULL) {}; | ||||
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_QSignalMapper : public QObject | ||||
{ Q_OBJECT | ||||
public: | ||||
public slots: | ||||
QSignalMapper* new_QSignalMapper(QObject* parent = 0); | ||||
void delete_QSignalMapper(QSignalMapper* obj) { delete obj; } | ||||
florianlink
|
r120 | QObject* mapping(QSignalMapper* theWrappedObject, QObject* object) const; | ||
florianlink
|
r128 | QObject* mapping(QSignalMapper* theWrappedObject, const QString& text) const; | ||
QObject* mapping(QSignalMapper* theWrappedObject, int id) const; | ||||
florianlink
|
r110 | void removeMappings(QSignalMapper* theWrappedObject, QObject* sender); | ||
florianlink
|
r120 | void setMapping(QSignalMapper* theWrappedObject, QObject* sender, QObject* object); | ||
florianlink
|
r110 | void setMapping(QSignalMapper* theWrappedObject, QObject* sender, const QString& text); | ||
florianlink
|
r120 | void setMapping(QSignalMapper* theWrappedObject, QObject* sender, int id); | ||
florianlink
|
r110 | }; | ||
class PythonQtShell_QSignalTransition : public QSignalTransition | ||||
{ | ||||
public: | ||||
PythonQtShell_QSignalTransition(QObject* sender, const char* signal, QState* sourceState = 0):QSignalTransition(sender, signal, sourceState),_wrapper(NULL) {}; | ||||
PythonQtShell_QSignalTransition(QState* sourceState = 0):QSignalTransition(sourceState),_wrapper(NULL) {}; | ||||
virtual void childEvent(QChildEvent* arg__1); | ||||
virtual void customEvent(QEvent* arg__1); | ||||
florianlink
|
r128 | virtual bool event(QEvent* e); | ||
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2); | ||||
virtual bool eventTest(QEvent* event); | ||||
virtual void onTransition(QEvent* event); | ||||
florianlink
|
r120 | virtual void timerEvent(QTimerEvent* arg__1); | ||
florianlink
|
r110 | |||
PythonQtInstanceWrapper* _wrapper; | ||||
}; | ||||
class PythonQtPublicPromoter_QSignalTransition : public QSignalTransition | ||||
{ public: | ||||
inline bool promoted_event(QEvent* e) { return QSignalTransition::event(e); } | ||||
inline bool promoted_eventTest(QEvent* event) { return QSignalTransition::eventTest(event); } | ||||
florianlink
|
r128 | inline void promoted_onTransition(QEvent* event) { QSignalTransition::onTransition(event); } | ||
florianlink
|
r110 | }; | ||
class PythonQtWrapper_QSignalTransition : public QObject | ||||
{ Q_OBJECT | ||||
public: | ||||
public slots: | ||||
QSignalTransition* new_QSignalTransition(QObject* sender, const char* signal, QState* sourceState = 0); | ||||
QSignalTransition* new_QSignalTransition(QState* sourceState = 0); | ||||
void delete_QSignalTransition(QSignalTransition* obj) { delete obj; } | ||||
bool event(QSignalTransition* theWrappedObject, QEvent* e); | ||||
florianlink
|
r128 | bool eventTest(QSignalTransition* theWrappedObject, QEvent* event); | ||
florianlink
|
r110 | void onTransition(QSignalTransition* theWrappedObject, QEvent* event); | ||
QObject* senderObject(QSignalTransition* theWrappedObject) const; | ||||
florianlink
|
r128 | void setSenderObject(QSignalTransition* theWrappedObject, QObject* sender); | ||
florianlink
|
r110 | void setSignal(QSignalTransition* theWrappedObject, const QByteArray& signal); | ||
florianlink
|
r128 | QByteArray signal(QSignalTransition* theWrappedObject) const; | ||
florianlink
|
r99 | }; | ||
class PythonQtShell_QSocketNotifier : public QSocketNotifier | ||||
{ | ||||
public: | ||||
PythonQtShell_QSocketNotifier(int socket, QSocketNotifier::Type arg__2, QObject* parent = 0):QSocketNotifier(socket, arg__2, parent),_wrapper(NULL) {}; | ||||
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 PythonQtPublicPromoter_QSocketNotifier : public QSocketNotifier | ||||
{ public: | ||||
inline bool promoted_event(QEvent* arg__1) { return QSocketNotifier::event(arg__1); } | ||||
}; | ||||
class PythonQtWrapper_QSocketNotifier : public QObject | ||||
{ Q_OBJECT | ||||
public: | ||||
Q_ENUMS(Type ) | ||||
enum Type{ | ||||
Read = QSocketNotifier::Read, Write = QSocketNotifier::Write, Exception = QSocketNotifier::Exception}; | ||||
public slots: | ||||
QSocketNotifier* new_QSocketNotifier(int socket, QSocketNotifier::Type arg__2, QObject* parent = 0); | ||||
void delete_QSocketNotifier(QSocketNotifier* obj) { delete obj; } | ||||
bool event(QSocketNotifier* theWrappedObject, QEvent* arg__1); | ||||
bool isEnabled(QSocketNotifier* theWrappedObject) const; | ||||
florianlink
|
r128 | int socket(QSocketNotifier* theWrappedObject) const; | ||
florianlink
|
r99 | QSocketNotifier::Type type(QSocketNotifier* theWrappedObject) const; | ||
}; | ||||
florianlink
|
r110 | class PythonQtShell_QState : public QState | ||
{ | ||||
public: | ||||
PythonQtShell_QState(QState* parent = 0):QState(parent),_wrapper(NULL) {}; | ||||
PythonQtShell_QState(QState::ChildMode childMode, QState* parent = 0):QState(childMode, parent),_wrapper(NULL) {}; | ||||
virtual void childEvent(QChildEvent* arg__1); | ||||
virtual void customEvent(QEvent* arg__1); | ||||
florianlink
|
r128 | virtual bool event(QEvent* e); | ||
virtual bool eventFilter(QObject* arg__1, QEvent* arg__2); | ||||
virtual void onEntry(QEvent* event); | ||||
virtual void onExit(QEvent* event); | ||||
florianlink
|
r120 | virtual void timerEvent(QTimerEvent* arg__1); | ||
florianlink
|
r110 | |||
PythonQtInstanceWrapper* _wrapper; | ||||
}; | ||||
class PythonQtPublicPromoter_QState : public QState | ||||
{ public: | ||||
inline bool promoted_event(QEvent* e) { return QState::event(e); } | ||||
inline void promoted_onEntry(QEvent* event) { QState::onEntry(event); } | ||||
florianlink
|
r128 | inline void promoted_onExit(QEvent* event) { QState::onExit(event); } | ||
florianlink
|
r110 | }; | ||
class PythonQtWrapper_QState : public QObject | ||||
{ Q_OBJECT | ||||
public: | ||||
public slots: | ||||
QState* new_QState(QState* parent = 0); | ||||
QState* new_QState(QState::ChildMode childMode, QState* parent = 0); | ||||
void delete_QState(QState* obj) { delete obj; } | ||||
florianlink
|
r128 | QAbstractTransition* addTransition(QState* theWrappedObject, QAbstractState* target); | ||
void addTransition(QState* theWrappedObject, QAbstractTransition* transition); | ||||
QSignalTransition* addTransition(QState* theWrappedObject, QObject* sender, const char* signal, QAbstractState* target); | ||||
void assignProperty(QState* theWrappedObject, QObject* object, const char* name, const QVariant& value); | ||||
QState::ChildMode childMode(QState* theWrappedObject) const; | ||||
QAbstractState* errorState(QState* theWrappedObject) const; | ||||
florianlink
|
r110 | bool event(QState* theWrappedObject, QEvent* e); | ||
QAbstractState* initialState(QState* theWrappedObject) const; | ||||
void onEntry(QState* theWrappedObject, QEvent* event); | ||||
florianlink
|
r128 | void onExit(QState* theWrappedObject, QEvent* event); | ||
void removeTransition(QState* theWrappedObject, QAbstractTransition* transition); | ||||
florianlink
|
r110 | void setChildMode(QState* theWrappedObject, QState::ChildMode mode); | ||
florianlink
|
r120 | void setErrorState(QState* theWrappedObject, QAbstractState* state); | ||
florianlink
|
r128 | void setInitialState(QState* theWrappedObject, QAbstractState* state); | ||
florianlink
|
r110 | }; | ||
class PythonQtShell_QStateMachine : public QStateMachine | ||||
{ | ||||
public: | ||||
PythonQtShell_QStateMachine(QObject* parent = 0):QStateMachine(parent),_wrapper(NULL) {}; | ||||
virtual void beginMicrostep(QEvent* event); | ||||
florianlink
|
r120 | virtual void beginSelectTransitions(QEvent* event); | ||
florianlink
|
r110 | virtual void childEvent(QChildEvent* arg__1); | ||
florianlink
|
r117 | virtual void customEvent(QEvent* arg__1); | ||
florianlink
|
r128 | virtual void endMicrostep(QEvent* event); | ||
virtual void endSelectTransitions(QEvent* event); | ||||
virtual bool event(QEvent* e); | ||||
virtual bool eventFilter(QObject* watched, QEvent* event); | ||||
virtual void onEntry(QEvent* event); | ||||
virtual void onExit(QEvent* event); | ||||
florianlink
|
r120 | virtual void timerEvent(QTimerEvent* arg__1); | ||
florianlink
|
r110 | |||
PythonQtInstanceWrapper* _wrapper; | ||||
}; | ||||
class PythonQtPublicPromoter_QStateMachine : public QStateMachine | ||||
{ public: | ||||
inline void promoted_beginMicrostep(QEvent* event) { QStateMachine::beginMicrostep(event); } | ||||
florianlink
|
r120 | inline void promoted_beginSelectTransitions(QEvent* event) { QStateMachine::beginSelectTransitions(event); } | ||
florianlink
|
r110 | inline void promoted_endMicrostep(QEvent* event) { QStateMachine::endMicrostep(event); } | ||
florianlink
|
r128 | inline void promoted_endSelectTransitions(QEvent* event) { QStateMachine::endSelectTransitions(event); } | ||
inline bool promoted_event(QEvent* e) { return QStateMachine::event(e); } | ||||
inline bool promoted_eventFilter(QObject* watched, QEvent* event) { return QStateMachine::eventFilter(watched, event); } | ||||
inline void promoted_onEntry(QEvent* event) { QStateMachine::onEntry(event); } | ||||
inline void promoted_onExit(QEvent* event) { QStateMachine::onExit(event); } | ||||
florianlink
|
r110 | }; | ||
class PythonQtWrapper_QStateMachine : public QObject | ||||
{ Q_OBJECT | ||||
public: | ||||
Q_ENUMS(Error EventPriority ) | ||||
enum Error{ | ||||
NoError = QStateMachine::NoError, NoInitialStateError = QStateMachine::NoInitialStateError, NoDefaultStateInHistoryStateError = QStateMachine::NoDefaultStateInHistoryStateError, NoCommonAncestorForTransitionError = QStateMachine::NoCommonAncestorForTransitionError}; | ||||
enum EventPriority{ | ||||
NormalPriority = QStateMachine::NormalPriority, HighPriority = QStateMachine::HighPriority}; | ||||
public slots: | ||||
QStateMachine* new_QStateMachine(QObject* parent = 0); | ||||
void delete_QStateMachine(QStateMachine* obj) { delete obj; } | ||||
florianlink
|
r128 | void addDefaultAnimation(QStateMachine* theWrappedObject, QAbstractAnimation* animation); | ||
void addState(QStateMachine* theWrappedObject, QAbstractState* state); | ||||
florianlink
|
r110 | void beginMicrostep(QStateMachine* theWrappedObject, QEvent* event); | ||
florianlink
|
r128 | void beginSelectTransitions(QStateMachine* theWrappedObject, QEvent* event); | ||
bool cancelDelayedEvent(QStateMachine* theWrappedObject, int id); | ||||
void clearError(QStateMachine* theWrappedObject); | ||||
QSet<QAbstractState* > configuration(QStateMachine* theWrappedObject) const; | ||||
florianlink
|
r110 | QList<QAbstractAnimation* > defaultAnimations(QStateMachine* theWrappedObject) const; | ||
florianlink
|
r128 | void endMicrostep(QStateMachine* theWrappedObject, QEvent* event); | ||
void endSelectTransitions(QStateMachine* theWrappedObject, QEvent* event); | ||||
florianlink
|
r110 | QStateMachine::Error error(QStateMachine* theWrappedObject) const; | ||
florianlink
|
r128 | QString errorString(QStateMachine* theWrappedObject) const; | ||
bool event(QStateMachine* theWrappedObject, QEvent* e); | ||||
florianlink
|
r120 | bool eventFilter(QStateMachine* theWrappedObject, QObject* watched, QEvent* event); | ||
florianlink
|
r128 | QStateMachine::RestorePolicy globalRestorePolicy(QStateMachine* theWrappedObject) const; | ||
bool isAnimated(QStateMachine* theWrappedObject) const; | ||||
bool isRunning(QStateMachine* theWrappedObject) const; | ||||
void onEntry(QStateMachine* theWrappedObject, QEvent* event); | ||||
void onExit(QStateMachine* theWrappedObject, QEvent* event); | ||||
int postDelayedEvent(QStateMachine* theWrappedObject, QEvent* event, int delay); | ||||
florianlink
|
r110 | void postEvent(QStateMachine* theWrappedObject, QEvent* event, QStateMachine::EventPriority priority = QStateMachine::NormalPriority); | ||
florianlink
|
r120 | void removeDefaultAnimation(QStateMachine* theWrappedObject, QAbstractAnimation* animation); | ||
florianlink
|
r128 | void removeState(QStateMachine* theWrappedObject, QAbstractState* state); | ||
void setAnimated(QStateMachine* theWrappedObject, bool enabled); | ||||
void setGlobalRestorePolicy(QStateMachine* theWrappedObject, QStateMachine::RestorePolicy restorePolicy); | ||||
florianlink
|
r110 | }; | ||
class PythonQtWrapper_QStateMachine_SignalEvent : public QObject | ||||
{ Q_OBJECT | ||||
public: | ||||
public slots: | ||||
QStateMachine::SignalEvent* new_QStateMachine_SignalEvent(QObject* sender, int signalIndex, const QList<QVariant >& arguments); | ||||
void delete_QStateMachine_SignalEvent(QStateMachine::SignalEvent* obj) { delete obj; } | ||||
QList<QVariant > arguments(QStateMachine::SignalEvent* theWrappedObject) const; | ||||
florianlink
|
r128 | QObject* sender(QStateMachine::SignalEvent* theWrappedObject) const; | ||
florianlink
|
r120 | int signalIndex(QStateMachine::SignalEvent* theWrappedObject) const; | ||
florianlink
|
r110 | }; | ||
class PythonQtWrapper_QStateMachine_WrappedEvent : public QObject | ||||
{ Q_OBJECT | ||||
public: | ||||
public slots: | ||||
QStateMachine::WrappedEvent* new_QStateMachine_WrappedEvent(QObject* object, QEvent* event); | ||||
void delete_QStateMachine_WrappedEvent(QStateMachine::WrappedEvent* obj) { delete obj; } | ||||
florianlink
|
r117 | QEvent* event(QStateMachine::WrappedEvent* theWrappedObject) const; | ||
florianlink
|
r128 | QObject* object(QStateMachine::WrappedEvent* theWrappedObject) const; | ||
florianlink
|
r110 | }; | ||
florianlink
|
r99 | class PythonQtWrapper_QStringMatcher : public QObject | ||
{ Q_OBJECT | ||||
public: | ||||
public slots: | ||||
QStringMatcher* new_QStringMatcher(); | ||||
QStringMatcher* new_QStringMatcher(const QString& pattern, Qt::CaseSensitivity cs = Qt::CaseSensitive); | ||||
QStringMatcher* new_QStringMatcher(const QStringMatcher& other); | ||||
void delete_QStringMatcher(QStringMatcher* obj) { delete obj; } | ||||
florianlink
|
r120 | Qt::CaseSensitivity caseSensitivity(QStringMatcher* theWrappedObject) const; | ||
florianlink
|
r128 | int indexIn(QStringMatcher* theWrappedObject, const QString& str, int from = 0) const; | ||
QString pattern(QStringMatcher* theWrappedObject) const; | ||||
florianlink
|
r99 | void setCaseSensitivity(QStringMatcher* theWrappedObject, Qt::CaseSensitivity cs); | ||
florianlink
|
r128 | void setPattern(QStringMatcher* theWrappedObject, const QString& pattern); | ||
florianlink
|
r99 | }; | ||
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; } | ||||
florianlink
|
r128 | bool acquire(QSystemSemaphore* theWrappedObject); | ||
florianlink
|
r99 | 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) {}; | ||||
florianlink
|
r128 | 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); | ||||
florianlink
|
r99 | virtual QAbstractFileEngine* fileEngine() const; | ||
florianlink
|
r128 | virtual bool isSequential() const; | ||
florianlink
|
r99 | virtual bool open(QIODevice::OpenMode flags); | ||
florianlink
|
r128 | virtual qint64 pos() const; | ||
florianlink
|
r120 | virtual qint64 readData(char* data, qint64 maxlen); | ||
florianlink
|
r110 | virtual qint64 readLineData(char* data, qint64 maxlen); | ||
florianlink
|
r99 | virtual bool reset(); | ||
florianlink
|
r128 | virtual bool seek(qint64 offset); | ||
virtual qint64 size() const; | ||||
virtual void timerEvent(QTimerEvent* arg__1); | ||||
florianlink
|
r120 | virtual bool waitForBytesWritten(int msecs); | ||
virtual bool waitForReadyRead(int msecs); | ||||
florianlink
|
r128 | virtual qint64 writeData(const char* data, qint64 len); | ||
florianlink
|
r99 | |||
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; } | ||||
florianlink
|
r120 | bool autoRemove(QTemporaryFile* theWrappedObject) const; | ||
florianlink
|
r110 | QTemporaryFile* static_QTemporaryFile_createLocalFile(QFile& file); | ||
florianlink
|
r99 | QTemporaryFile* static_QTemporaryFile_createLocalFile(const QString& fileName); | ||
florianlink
|
r128 | QAbstractFileEngine* fileEngine(QTemporaryFile* theWrappedObject) const; | ||
QString fileName(QTemporaryFile* theWrappedObject) const; | ||||
florianlink
|
r110 | QString fileTemplate(QTemporaryFile* theWrappedObject) const; | ||
florianlink
|
r128 | bool open(QTemporaryFile* theWrappedObject); | ||
bool open(QTemporaryFile* theWrappedObject, QIODevice::OpenMode flags); | ||||
void setAutoRemove(QTemporaryFile* theWrappedObject, bool b); | ||||
void setFileTemplate(QTemporaryFile* theWrappedObject, const QString& name); | ||||
florianlink
|
r99 | }; | ||
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; | ||||
florianlink
|
r128 | bool isAtBoundary(QTextBoundaryFinder* theWrappedObject) const; | ||
bool isValid(QTextBoundaryFinder* theWrappedObject) const; | ||||
florianlink
|
r120 | int position(QTextBoundaryFinder* theWrappedObject) const; | ||
void setPosition(QTextBoundaryFinder* theWrappedObject, int position); | ||||
florianlink
|
r128 | QString string(QTextBoundaryFinder* theWrappedObject) const; | ||
florianlink
|
r110 | void toEnd(QTextBoundaryFinder* theWrappedObject); | ||
florianlink
|
r128 | int toNextBoundary(QTextBoundaryFinder* theWrappedObject); | ||
florianlink
|
r110 | int toPreviousBoundary(QTextBoundaryFinder* theWrappedObject); | ||
florianlink
|
r128 | void toStart(QTextBoundaryFinder* theWrappedObject); | ||
QTextBoundaryFinder::BoundaryType type(QTextBoundaryFinder* theWrappedObject) const; | ||||
florianlink
|
r99 | }; | ||
class PythonQtShell_QTextCodec : public QTextCodec | ||||
{ | ||||
public: | ||||
PythonQtShell_QTextCodec():QTextCodec(),_wrapper(NULL) {}; | ||||
florianlink
|
r128 | virtual QList<QByteArray > aliases() const; | ||
florianlink
|
r120 | virtual QByteArray convertFromUnicode(const QChar* in, int length, QTextCodec::ConverterState* state) const; | ||
florianlink
|
r110 | virtual QString convertToUnicode(const char* in, int length, QTextCodec::ConverterState* state) const; | ||
florianlink
|
r128 | virtual int mibEnum() const; | ||
virtual QByteArray name() const; | ||||
florianlink
|
r99 | |||
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 ) | ||||
florianlink
|
r110 | Q_FLAGS(ConversionFlags ) | ||
enum ConversionFlag{ | ||||
DefaultConversion = QTextCodec::DefaultConversion, ConvertInvalidToNull = QTextCodec::ConvertInvalidToNull, IgnoreHeader = QTextCodec::IgnoreHeader, FreeFunction = QTextCodec::FreeFunction}; | ||||
Q_DECLARE_FLAGS(ConversionFlags, ConversionFlag) | ||||
florianlink
|
r99 | public slots: | ||
florianlink
|
r128 | QList<QByteArray > aliases(QTextCodec* theWrappedObject) const; | ||
QList<QByteArray > static_QTextCodec_availableCodecs(); | ||||
QList<int > static_QTextCodec_availableMibs(); | ||||
florianlink
|
r110 | bool canEncode(QTextCodec* theWrappedObject, QChar arg__1) const; | ||
florianlink
|
r120 | bool canEncode(QTextCodec* theWrappedObject, const QString& arg__1) const; | ||
florianlink
|
r128 | 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); | ||||
florianlink
|
r120 | QTextCodec* static_QTextCodec_codecForName(const QByteArray& name); | ||
QTextCodec* static_QTextCodec_codecForName(const char* name); | ||||
florianlink
|
r128 | QTextCodec* static_QTextCodec_codecForUtfText(const QByteArray& ba); | ||
QTextCodec* static_QTextCodec_codecForUtfText(const QByteArray& ba, QTextCodec* defaultCodec); | ||||
florianlink
|
r110 | QByteArray fromUnicode(QTextCodec* theWrappedObject, const QString& uc) const; | ||
QTextDecoder* makeDecoder(QTextCodec* theWrappedObject) const; | ||||
florianlink
|
r128 | QTextEncoder* makeEncoder(QTextCodec* theWrappedObject) const; | ||
void static_QTextCodec_setCodecForCStrings(QTextCodec* c); | ||||
void static_QTextCodec_setCodecForLocale(QTextCodec* c); | ||||
florianlink
|
r120 | void static_QTextCodec_setCodecForTr(QTextCodec* c); | ||
florianlink
|
r110 | QString toUnicode(QTextCodec* theWrappedObject, const QByteArray& arg__1) const; | ||
florianlink
|
r99 | }; | ||
class PythonQtWrapper_QTextDecoder : public QObject | ||||
{ Q_OBJECT | ||||
public: | ||||
public slots: | ||||
QTextDecoder* new_QTextDecoder(const QTextCodec* codec); | ||||
void delete_QTextDecoder(QTextDecoder* obj) { delete obj; } | ||||
bool hasFailure(QTextDecoder* theWrappedObject) const; | ||||
florianlink
|
r128 | QString toUnicode(QTextDecoder* theWrappedObject, const QByteArray& ba); | ||
florianlink
|
r99 | }; | ||
class PythonQtWrapper_QTextEncoder : public QObject | ||||
{ Q_OBJECT | ||||
public: | ||||
public slots: | ||||
QTextEncoder* new_QTextEncoder(const QTextCodec* codec); | ||||
void delete_QTextEncoder(QTextEncoder* obj) { delete obj; } | ||||
QByteArray fromUnicode(QTextEncoder* theWrappedObject, const QString& str); | ||||
florianlink
|
r120 | bool hasFailure(QTextEncoder* theWrappedObject) const; | ||
florianlink
|
r99 | }; | ||
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) {}; | ||||
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}; | ||||
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; } | ||||
florianlink
|
r128 | bool atEnd(QTextStream* theWrappedObject) const; | ||
bool autoDetectUnicode(QTextStream* theWrappedObject) const; | ||||
QTextCodec* codec(QTextStream* theWrappedObject) const; | ||||
florianlink
|
r99 | QIODevice* device(QTextStream* theWrappedObject) const; | ||
QTextStream::FieldAlignment fieldAlignment(QTextStream* theWrappedObject) const; | ||||
florianlink
|
r128 | int fieldWidth(QTextStream* theWrappedObject) const; | ||
florianlink
|
r120 | void flush(QTextStream* theWrappedObject); | ||
florianlink
|
r128 | bool generateByteOrderMark(QTextStream* theWrappedObject) const; | ||
int integerBase(QTextStream* theWrappedObject) const; | ||||
QLocale locale(QTextStream* theWrappedObject) const; | ||||
florianlink
|
r120 | QTextStream::NumberFlags numberFlags(QTextStream* theWrappedObject) const; | ||
florianlink
|
r128 | QTextStream* writeBoolean(QTextStream* theWrappedObject, QBool b); | ||
QTextStream* writeByte(QTextStream* theWrappedObject, char ch); | ||||
florianlink
|
r110 | QTextStream* writeDouble(QTextStream* theWrappedObject, double f); | ||
florianlink
|
r128 | QTextStream* writeFloat(QTextStream* theWrappedObject, float f); | ||
florianlink
|
r110 | QTextStream* writeLongLong(QTextStream* theWrappedObject, qlonglong i); | ||
florianlink
|
r99 | QTextStream* writeInt(QTextStream* theWrappedObject, signed int i); | ||
QTextStream* writeShort(QTextStream* theWrappedObject, signed short i); | ||||
florianlink
|
r120 | QTextStream* readByte(QTextStream* theWrappedObject, char& ch); | ||
QTextStream* readDouble(QTextStream* theWrappedObject, double& f); | ||||
florianlink
|
r128 | QTextStream* readFloat(QTextStream* theWrappedObject, float& f); | ||
QTextStream* readLongLong(QTextStream* theWrappedObject, qlonglong& i); | ||||
florianlink
|
r99 | QTextStream* readInt(QTextStream* theWrappedObject, signed int& i); | ||
florianlink
|
r128 | 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); | ||||
florianlink
|
r99 | void setFieldAlignment(QTextStream* theWrappedObject, QTextStream::FieldAlignment alignment); | ||
florianlink
|
r128 | 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); | ||||
florianlink
|
r110 | void setRealNumberPrecision(QTextStream* theWrappedObject, int precision); | ||
florianlink
|
r120 | void setStatus(QTextStream* theWrappedObject, QTextStream::Status status); | ||
florianlink
|
r128 | void skipWhiteSpace(QTextStream* theWrappedObject); | ||
QTextStream::Status status(QTextStream* theWrappedObject) const; | ||||
florianlink
|
r99 | }; | ||
class PythonQtShell_QThreadPool : public QThreadPool | ||||
{ | ||||
public: | ||||
PythonQtShell_QThreadPool(QObject* parent = 0):QThreadPool(parent),_wrapper(NULL) {}; | ||||
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_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; | ||||
florianlink
|
r128 | int expiryTimeout(QThreadPool* theWrappedObject) const; | ||
QThreadPool* static_QThreadPool_globalInstance(); | ||||
florianlink
|
r99 | int maxThreadCount(QThreadPool* theWrappedObject) const; | ||
florianlink
|
r128 | void releaseThread(QThreadPool* theWrappedObject); | ||
florianlink
|
r120 | void reserveThread(QThreadPool* theWrappedObject); | ||
florianlink
|
r99 | void setExpiryTimeout(QThreadPool* theWrappedObject, int expiryTimeout); | ||
florianlink
|
r128 | 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); | ||||
florianlink
|
r99 | }; | ||
class PythonQtShell_QTimeLine : public QTimeLine | ||||
{ | ||||
public: | ||||
PythonQtShell_QTimeLine(int duration = 1000, QObject* parent = 0):QTimeLine(duration, parent),_wrapper(NULL) {}; | ||||
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 void timerEvent(QTimerEvent* event); | ||||
virtual qreal valueForTime(int msec) const; | ||||
florianlink
|
r99 | |||
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; } | ||||
florianlink
|
r128 | int currentFrame(QTimeLine* theWrappedObject) const; | ||
int currentTime(QTimeLine* theWrappedObject) const; | ||||
qreal currentValue(QTimeLine* theWrappedObject) const; | ||||
florianlink
|
r110 | QTimeLine::CurveShape curveShape(QTimeLine* theWrappedObject) const; | ||
florianlink
|
r128 | QTimeLine::Direction direction(QTimeLine* theWrappedObject) const; | ||
florianlink
|
r120 | int duration(QTimeLine* theWrappedObject) const; | ||
florianlink
|
r128 | QEasingCurve easingCurve(QTimeLine* theWrappedObject) const; | ||
int endFrame(QTimeLine* theWrappedObject) const; | ||||
int frameForTime(QTimeLine* theWrappedObject, int msec) const; | ||||
florianlink
|
r120 | int loopCount(QTimeLine* theWrappedObject) const; | ||
florianlink
|
r128 | 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); | ||||
florianlink
|
r99 | void setFrameRange(QTimeLine* theWrappedObject, int startFrame, int endFrame); | ||
florianlink
|
r128 | void setLoopCount(QTimeLine* theWrappedObject, int count); | ||
void setStartFrame(QTimeLine* theWrappedObject, int frame); | ||||
florianlink
|
r120 | void setUpdateInterval(QTimeLine* theWrappedObject, int interval); | ||
florianlink
|
r128 | int startFrame(QTimeLine* theWrappedObject) const; | ||
florianlink
|
r99 | QTimeLine::State state(QTimeLine* theWrappedObject) const; | ||
florianlink
|
r128 | void timerEvent(QTimeLine* theWrappedObject, QTimerEvent* event); | ||
florianlink
|
r99 | int updateInterval(QTimeLine* theWrappedObject) const; | ||
florianlink
|
r128 | qreal valueForTime(QTimeLine* theWrappedObject, int msec) const; | ||
}; | ||||
class PythonQtShell_QTimer : public QTimer | ||||
{ | ||||
public: | ||||
PythonQtShell_QTimer(QObject* parent = 0):QTimer(parent),_wrapper(NULL) {}; | ||||
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; | ||||
florianlink
|
r99 | }; | ||