GIT_REPOSITORIES/LPP/PythonQt Files · generated_cpp/com_trolltech_qt_core/com_trolltech_qt_core2.h

Now Works with Python 2 & 3, Qt 4 & 5....

Now Works with Python 2 & 3, Qt 4 & 5. CMake now generates different librariy files depending on the linked Qt/Python versions: PythonQt - Qt 4.x + Python 2.x PythonQt_3 - Qt 4.x + Python 3.x PythonQt5 - Qt 5.x + Python 2.x PythonQt5_3 - Qt 5.x + Python 3.x Fix Qt 4 build.

florianlink - - Load All Authors

File last commit:

r186:69e742701130


                r208:1476f2d2cf46

Download file

             com_trolltech_qt_core2.h
        
                    732 lines
            
             | 31.3 KiB
            
                | text/x-c
            
             |
                CLexer
            
             / generated_cpp / com_trolltech_qt_core / com_trolltech_qt_core2.h
          
                    History
                
                 |
                  Source
                 | Raw
                 |Copy content
                 |Copy permalink

        florianlink
    
updated to Qt 4.6 API...

              r110
            
      #include <PythonQt.h>

      #include <QObject>

        florianlink
    
updated to Qt 4.8 wrappers...

              r186
            
      #include <QTextCodec>

        florianlink
    
updated to Qt 4.6 API...

              r110
            
      #include <QVariant>

      #include <qanimationgroup.h>

      #include <qbytearray.h>

      #include <qcoreevent.h>

      #include <qdatastream.h>

      #include <qeasingcurve.h>

        florianlink
    
updated to Qt 4.8 wrappers...

              r186
            
      #include <qfile.h>

      #include <qiodevice.h>

        florianlink
    
updated to Qt 4.6 API...

              r110
            
      #include <qlist.h>

        florianlink
    
updated to Qt 4.8 wrappers...

              r186
            
      #include <qlocale.h>

        florianlink
    
updated to Qt 4.6 API...

              r110
            
      #include <qmutex.h>

      #include <qobject.h>

      #include <qpair.h>

      #include <qreadwritelock.h>

        florianlink
    
updated to Qt 4.8 wrappers...

              r186
            
      #include <qrunnable.h>

      #include <qsystemsemaphore.h>

        florianlink
    
updated to Qt 4.6 API...

              r110
            
      #include <qtconcurrentexception.h>

      #include <qtconcurrentreducekernel.h>

      #include <qtconcurrentthreadengine.h>

        florianlink
    
updated to Qt 4.8 wrappers...

              r186
            
      #include <qtemporaryfile.h>

      #include <qtextboundaryfinder.h>

      #include <qtextcodec.h>

      #include <qtextstream.h>

      #include <qthreadpool.h>

      #include <qtimeline.h>

      #include <qtimer.h>

        florianlink
    
updated to Qt 4.6 API...

              r110
            
      #include <qtranslator.h>

      #include <quuid.h>

      #include <qvariantanimation.h>

      #include <qvector.h>

      #include <qwaitcondition.h>

      #include <qxmlstream.h>

        florianlink
    
updated to Qt 4.8 wrappers...

              r186
            
      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;

      };

        florianlink
    
updated to Qt 4.6 API...

              r110
            
      class PythonQtShell_QTimerEvent : public QTimerEvent

      {

      public:

          PythonQtShell_QTimerEvent(int  timerId):QTimerEvent(timerId),_wrapper(NULL) {};

        florianlink
    
updated to Qt 4.8 wrappers...

              r186
            
         ~PythonQtShell_QTimerEvent();

        florianlink
    
updated to Qt 4.6 API...

              r110
            
        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) {};

        florianlink
    
updated to Qt 4.8 wrappers...

              r186
            
         ~PythonQtShell_QTranslator();

        florianlink
    
updated to new operators...

              r120
            
      virtual void childEvent(QChildEvent*  arg__1);

      virtual void customEvent(QEvent*  arg__1);

        florianlink
    
updated to improved generator...

              r128
            
      virtual bool  event(QEvent*  arg__1);

      virtual bool  eventFilter(QObject*  arg__1, QEvent*  arg__2);

      virtual bool  isEmpty() const;

        florianlink
    
updated to new operators...

              r120
            
      virtual void timerEvent(QTimerEvent*  arg__1);

        florianlink
    
updated to improved generator...

              r128
            
      virtual QString  translate(const char*  context, const char*  sourceText, const char*  disambiguation = 0) const;

        florianlink
    
updated to Qt 4.6 API...

              r110
            
        PythonQtInstanceWrapper* _wrapper; 

      };

      class PythonQtPublicPromoter_QTranslator : public QTranslator

      { public:

      inline bool  promoted_isEmpty() const { return QTranslator::isEmpty(); }

        florianlink
    
updated to improved generator...

              r128
            
      inline QString  promoted_translate(const char*  context, const char*  sourceText, const char*  disambiguation = 0) const { return QTranslator::translate(context, sourceText, disambiguation); }

        florianlink
    
updated to Qt 4.6 API...

              r110
            
      };

      class PythonQtWrapper_QTranslator : public QObject

      { Q_OBJECT

      public:

      public slots:

      QTranslator* new_QTranslator(QObject*  parent = 0);

      void delete_QTranslator(QTranslator* obj) { delete obj; } 

        florianlink
    
updated to improved generator...

              r128
            
         bool  isEmpty(QTranslator* theWrappedObject) const;

        florianlink
    
updated to Qt 4.8 wrappers...

              r186
            
         bool  load(QTranslator* theWrappedObject, const QLocale&  locale, const QString&  filename, const QString&  prefix = QString(), const QString&  directory = QString(), const QString&  suffix = QString());

        florianlink
    
updated to Qt 4.6 API...

              r110
            
         bool  load(QTranslator* theWrappedObject, const QString&  filename, const QString&  directory = QString(), const QString&  search_delimiters = QString(), const QString&  suffix = QString());

        florianlink
    
updated to improved generator...

              r128
            
         bool  load(QTranslator* theWrappedObject, const uchar*  data, int  len);

        florianlink
    
updated to Qt 4.6 API...

              r110
            
         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) {};

        florianlink
    
updated to Qt 4.8 wrappers...

              r186
            
          PythonQtShell_QUuid(const QByteArray&  arg__1):QUuid(arg__1),_wrapper(NULL) {};

        florianlink
    
updated to Qt 4.6 API...

              r110
            
          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) {};

        florianlink
    
updated to Qt 4.8 wrappers...

              r186
            
         ~PythonQtShell_QUuid();

        florianlink
    
updated to Qt 4.6 API...

              r110
            
        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();

        florianlink
    
updated to Qt 4.8 wrappers...

              r186
            
      QUuid* new_QUuid(const QByteArray&  arg__1);

        florianlink
    
updated to Qt 4.6 API...

              r110
            
      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; } 

        florianlink
    
updated to new operators...

              r120
            
         QUuid  static_QUuid_createUuid();

        florianlink
    
updated to Qt 4.8 wrappers...

              r186
            
         QUuid  static_QUuid_fromRfc4122(const QByteArray&  arg__1);

        florianlink
    
updated to Qt 4.6 API...

              r110
            
         bool  isNull(QUuid* theWrappedObject) const;

        florianlink
    
updated to improved generator...

              r128
            
         bool  __ne__(QUuid* theWrappedObject, const QUuid&  orig) const;

         bool  __lt__(QUuid* theWrappedObject, const QUuid&  other) const;

        florianlink
    
updated to Qt 4.6 API...

              r110
            
         void writeTo(QUuid* theWrappedObject, QDataStream&  arg__1);

        florianlink
    
updated to improved generator...

              r128
            
         bool  __eq__(QUuid* theWrappedObject, const QUuid&  orig) const;

         bool  __gt__(QUuid* theWrappedObject, const QUuid&  other) const;

        florianlink
    
updated to Qt 4.6 API...

              r110
            
         void readFrom(QUuid* theWrappedObject, QDataStream&  arg__1);

        florianlink
    
updated to Qt 4.8 wrappers...

              r186
            
         QByteArray  toByteArray(QUuid* theWrappedObject) const;

         QByteArray  toRfc4122(QUuid* theWrappedObject) const;

        florianlink
    
updated to improved generator...

              r128
            
         QString  toString(QUuid* theWrappedObject) const;

         QUuid::Variant  variant(QUuid* theWrappedObject) const;

         QUuid::Version  version(QUuid* theWrappedObject) const;

        florianlink
    
update with new py_ naming and field getters/setters...

              r117
            
          QString py_toString(QUuid*);

        florianlink
    
updated to new operators...

              r120
            
          bool __nonzero__(QUuid* obj) { return !obj->isNull(); }

        florianlink
    
update with new py_ naming and field getters/setters...

              r117
            
      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; }

        florianlink
    
updated to Qt 4.6 API...

              r110
            
      };

      class PythonQtShell_QVariantAnimation : public QVariantAnimation

      {

      public:

          PythonQtShell_QVariantAnimation(QObject*  parent = 0):QVariantAnimation(parent),_wrapper(NULL) {};

        florianlink
    
updated to Qt 4.8 wrappers...

              r186
            
         ~PythonQtShell_QVariantAnimation();

        florianlink
    
updated to Qt 4.6 API...

              r110
            
      virtual void childEvent(QChildEvent*  arg__1);

      virtual void customEvent(QEvent*  arg__1);

        florianlink
    
updated to improved generator...

              r128
            
      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;

        florianlink
    
updated to new operators...

              r120
            
      virtual void timerEvent(QTimerEvent*  arg__1);

        florianlink
    
updated to improved generator...

              r128
            
      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);

        florianlink
    
updated to Qt 4.6 API...

              r110
            
        PythonQtInstanceWrapper* _wrapper; 

      };

      class PythonQtPublicPromoter_QVariantAnimation : public QVariantAnimation

      { public:

      inline int  promoted_duration() const { return QVariantAnimation::duration(); }

        florianlink
    
updated to improved generator...

              r128
            
      inline bool  promoted_event(QEvent*  event) { return QVariantAnimation::event(event); }

        florianlink
    
updated to new operators...

              r120
            
      inline QVariant  promoted_interpolated(const QVariant&  from, const QVariant&  to, qreal  progress) const { return QVariantAnimation::interpolated(from, to, progress); }

        florianlink
    
updated to improved generator...

              r128
            
      inline void promoted_updateCurrentTime(int  arg__1) { QVariantAnimation::updateCurrentTime(arg__1); }

        florianlink
    
updated to Qt 4.6 API...

              r110
            
      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;

        florianlink
    
updated to improved generator...

              r128
            
         QEasingCurve  easingCurve(QVariantAnimation* theWrappedObject) const;

        florianlink
    
updated to new operators...

              r120
            
         QVariant  endValue(QVariantAnimation* theWrappedObject) const;

        florianlink
    
updated to improved generator...

              r128
            
         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;

        florianlink
    
updated to Qt 4.6 API...

              r110
            
         QVector<QPair<qreal , QVariant >  >  keyValues(QVariantAnimation* theWrappedObject) const;

        florianlink
    
updated to improved generator...

              r128
            
         void setDuration(QVariantAnimation* theWrappedObject, int  msecs);

        florianlink
    
updated to Qt 4.6 API...

              r110
            
         void setEasingCurve(QVariantAnimation* theWrappedObject, const QEasingCurve&  easing);

        florianlink
    
updated to improved generator...

              r128
            
         void setEndValue(QVariantAnimation* theWrappedObject, const QVariant&  value);

        florianlink
    
updated to Qt 4.6 API...

              r110
            
         void setKeyValueAt(QVariantAnimation* theWrappedObject, qreal  step, const QVariant&  value);

        florianlink
    
updated to improved generator...

              r128
            
         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);

        florianlink
    
updated to Qt 4.6 API...

              r110
            
         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; } 

        florianlink
    
updated to Qt 4.8 wrappers...

              r186
            
         bool  wait(QWaitCondition* theWrappedObject, QMutex*  mutex, unsigned long  time = ULONG_MAX);

         bool  wait(QWaitCondition* theWrappedObject, QReadWriteLock*  readWriteLock, unsigned long  time = ULONG_MAX);

        florianlink
    
updated to improved generator...

              r128
            
         void wakeAll(QWaitCondition* theWrappedObject);

        florianlink
    
updated to Qt 4.6 API...

              r110
            
         void wakeOne(QWaitCondition* theWrappedObject);

      };

      class PythonQtShell_QXmlStreamEntityResolver : public QXmlStreamEntityResolver

      {

      public:

          PythonQtShell_QXmlStreamEntityResolver():QXmlStreamEntityResolver(),_wrapper(NULL) {};

        florianlink
    
updated to Qt 4.8 wrappers...

              r186
            
         ~PythonQtShell_QXmlStreamEntityResolver();

        florianlink
    
updated to Qt 4.6 API...

              r110
            
      virtual QString  resolveEntity(const QString&  publicId, const QString&  systemId);

        florianlink
    
updated to improved generator...

              r128
            
      virtual QString  resolveUndeclaredEntity(const QString&  name);

        florianlink
    
updated to Qt 4.6 API...

              r110
            
        PythonQtInstanceWrapper* _wrapper; 

      };

      class PythonQtPublicPromoter_QXmlStreamEntityResolver : public QXmlStreamEntityResolver

      { public:

      inline QString  promoted_resolveEntity(const QString&  publicId, const QString&  systemId) { return QXmlStreamEntityResolver::resolveEntity(publicId, systemId); }

        florianlink
    
updated to improved generator...

              r128
            
      inline QString  promoted_resolveUndeclaredEntity(const QString&  name) { return QXmlStreamEntityResolver::resolveUndeclaredEntity(name); }

        florianlink
    
updated to Qt 4.6 API...

              r110
            
      };

      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);

        florianlink
    
updated to improved generator...

              r128
            
         QString  resolveUndeclaredEntity(QXmlStreamEntityResolver* theWrappedObject, const QString&  name);

        florianlink
    
updated to Qt 4.6 API...

              r110
            
      };

      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:

      };

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages