Documentation

type QVoid a = Object (CQVoid a) #

type TQVoid a = CQVoid a #

data CQVoid a #

type QObject a = Object (CQObject a) #

type TQObject a = CQObject a #

data CQObject a #

qCast_QObject :: Object a -> IO (QObject ()) #

type QObjectSc a = QObject (CQObjectSc a) #

type TQObjectSc a = TQObject (CQObjectSc a) #

data CQObjectSc a #

qCastList_QObject :: QqCastList_QObject a r => a -> r #

withQObjectResult :: IO (Ptr (TQObject a)) -> IO (QObject a) #

qObjectFromPtr :: Ptr (TQObject a) -> IO (QObject a) #

withQListQObjectResult :: IO (Ptr (TQListQObject ())) -> IO [QObject ()] #

qObjectListFromPtrList :: [Ptr (TQObject a)] -> IO [QObject a] #

type QListQObject a = Object (CQListQObject a) #

type TQListQObject a = CQListQObject a #

data CQListQObject a #

type QAbstractAnimation a = QObject (CQAbstractAnimation a) #

type TQAbstractAnimation a = TQObject (CQAbstractAnimation a) #

data CQAbstractAnimation a #

qCast_QAbstractAnimation :: Object a -> IO (QAbstractAnimation ()) #

type QAbstractAnimationSc a = QAbstractAnimation (CQAbstractAnimationSc a) #

type TQAbstractAnimationSc a = TQAbstractAnimation (CQAbstractAnimationSc a) #

data CQAbstractAnimationSc a #

qCastList_QAbstractAnimation :: QqCastList_QAbstractAnimation a r => a -> r #

withQAbstractAnimationResult :: IO (Ptr (TQAbstractAnimation a)) -> IO (QAbstractAnimation a) #

qAbstractAnimationFromPtr :: Ptr (TQAbstractAnimation a) -> IO (QAbstractAnimation a) #

qAbstractAnimationAddFinalizer :: QAbstractAnimation a -> IO () #

withQListQAbstractAnimationResult :: IO (Ptr (TQListQAbstractAnimation ())) -> IO [QAbstractAnimation ()] #

qAbstractAnimationListFromPtrList :: [Ptr (TQAbstractAnimation a)] -> IO [QAbstractAnimation a] #

type QListQAbstractAnimation a = Object (CQListQAbstractAnimation a) #

type TQListQAbstractAnimation a = CQListQAbstractAnimation a #

data CQListQAbstractAnimation a #

type QAbstractItemModel a = QObject (CQAbstractItemModel a) #

type TQAbstractItemModel a = TQObject (CQAbstractItemModel a) #

data CQAbstractItemModel a #

qCast_QAbstractItemModel :: Object a -> IO (QAbstractItemModel ()) #

type QAbstractItemModelSc a = QAbstractItemModel (CQAbstractItemModelSc a) #

type TQAbstractItemModelSc a = TQAbstractItemModel (CQAbstractItemModelSc a) #

data CQAbstractItemModelSc a #

qCastList_QAbstractItemModel :: QqCastList_QAbstractItemModel a r => a -> r #

withQAbstractItemModelResult :: IO (Ptr (TQAbstractItemModel a)) -> IO (QAbstractItemModel a) #

qAbstractItemModelFromPtr :: Ptr (TQAbstractItemModel a) -> IO (QAbstractItemModel a) #

qAbstractItemModelAddFinalizer :: QAbstractItemModel a -> IO () #

type QEvent a = Object (CQEvent a) #

type TQEvent a = CQEvent a #

data CQEvent a #

qCast_QEvent :: Object a -> IO (QEvent ()) #

type QEventSc a = QEvent (CQEventSc a) #

type TQEventSc a = TQEvent (CQEventSc a) #

data CQEventSc a #

qCastList_QEvent :: QqCastList_QEvent a r => a -> r #

withQEventResult :: IO (Ptr (TQEvent a)) -> IO (QEvent a) #

type QIODevice a = QObject (CQIODevice a) #

type TQIODevice a = TQObject (CQIODevice a) #

data CQIODevice a #

qCast_QIODevice :: Object a -> IO (QIODevice ()) #

type QIODeviceSc a = QIODevice (CQIODeviceSc a) #

type TQIODeviceSc a = TQIODevice (CQIODeviceSc a) #

data CQIODeviceSc a #

qCastList_QIODevice :: QqCastList_QIODevice a r => a -> r #

withQIODeviceResult :: IO (Ptr (TQIODevice a)) -> IO (QIODevice a) #

qIODeviceFromPtr :: Ptr (TQIODevice a) -> IO (QIODevice a) #

qIODeviceAddFinalizer :: QIODevice a -> IO () #

type QAbstractState a = QObject (CQAbstractState a) #

type TQAbstractState a = TQObject (CQAbstractState a) #

data CQAbstractState a #

qCast_QAbstractState :: Object a -> IO (QAbstractState ()) #

type QAbstractStateSc a = QAbstractState (CQAbstractStateSc a) #

type TQAbstractStateSc a = TQAbstractState (CQAbstractStateSc a) #

data CQAbstractStateSc a #

qCastList_QAbstractState :: QqCastList_QAbstractState a r => a -> r #

withQAbstractStateResult :: IO (Ptr (TQAbstractState a)) -> IO (QAbstractState a) #

qAbstractStateFromPtr :: Ptr (TQAbstractState a) -> IO (QAbstractState a) #

qAbstractStateAddFinalizer :: QAbstractState a -> IO () #

withQListQAbstractStateResult :: IO (Ptr (TQListQAbstractState ())) -> IO [QAbstractState ()] #

qAbstractStateListFromPtrList :: [Ptr (TQAbstractState a)] -> IO [QAbstractState a] #

type QListQAbstractState a = Object (CQListQAbstractState a) #

type TQListQAbstractState a = CQListQAbstractState a #

data CQListQAbstractState a #

type QAnimationGroup a = QAbstractAnimation (CQAnimationGroup a) #

type TQAnimationGroup a = TQAbstractAnimation (CQAnimationGroup a) #

data CQAnimationGroup a #

qCast_QAnimationGroup :: Object a -> IO (QAnimationGroup ()) #

type QAnimationGroupSc a = QAnimationGroup (CQAnimationGroupSc a) #

type TQAnimationGroupSc a = TQAnimationGroup (CQAnimationGroupSc a) #

data CQAnimationGroupSc a #

qCastList_QAnimationGroup :: QqCastList_QAnimationGroup a r => a -> r #

withQAnimationGroupResult :: IO (Ptr (TQAnimationGroup a)) -> IO (QAnimationGroup a) #

qAnimationGroupFromPtr :: Ptr (TQAnimationGroup a) -> IO (QAnimationGroup a) #

qAnimationGroupAddFinalizer :: QAnimationGroup a -> IO () #

type QAbstractProxyModel a = QAbstractItemModel (CQAbstractProxyModel a) #

type TQAbstractProxyModel a = TQAbstractItemModel (CQAbstractProxyModel a) #

data CQAbstractProxyModel a #

qCast_QAbstractProxyModel :: Object a -> IO (QAbstractProxyModel ()) #

type QAbstractProxyModelSc a = QAbstractProxyModel (CQAbstractProxyModelSc a) #

type TQAbstractProxyModelSc a = TQAbstractProxyModel (CQAbstractProxyModelSc a) #

data CQAbstractProxyModelSc a #

qCastList_QAbstractProxyModel :: QqCastList_QAbstractProxyModel a r => a -> r #

withQAbstractProxyModelResult :: IO (Ptr (TQAbstractProxyModel a)) -> IO (QAbstractProxyModel a) #

qAbstractProxyModelFromPtr :: Ptr (TQAbstractProxyModel a) -> IO (QAbstractProxyModel a) #

qAbstractProxyModelAddFinalizer :: QAbstractProxyModel a -> IO () #

type QFileDevice a = QIODevice (CQFileDevice a) #

type TQFileDevice a = TQIODevice (CQFileDevice a) #

data CQFileDevice a #

qCast_QFileDevice :: Object a -> IO (QFileDevice ()) #

type QFileDeviceSc a = QFileDevice (CQFileDeviceSc a) #

type TQFileDeviceSc a = TQFileDevice (CQFileDeviceSc a) #

data CQFileDeviceSc a #

qCastList_QFileDevice :: QqCastList_QFileDevice a r => a -> r #

withQFileDeviceResult :: IO (Ptr (TQFileDevice a)) -> IO (QFileDevice a) #

qFileDeviceFromPtr :: Ptr (TQFileDevice a) -> IO (QFileDevice a) #

qFileDeviceAddFinalizer :: QFileDevice a -> IO () #

type QAbstractTransition a = QObject (CQAbstractTransition a) #

type TQAbstractTransition a = TQObject (CQAbstractTransition a) #

data CQAbstractTransition a #

qCast_QAbstractTransition :: Object a -> IO (QAbstractTransition ()) #

type QAbstractTransitionSc a = QAbstractTransition (CQAbstractTransitionSc a) #

type TQAbstractTransitionSc a = TQAbstractTransition (CQAbstractTransitionSc a) #

data CQAbstractTransitionSc a #

qCastList_QAbstractTransition :: QqCastList_QAbstractTransition a r => a -> r #

withQAbstractTransitionResult :: IO (Ptr (TQAbstractTransition a)) -> IO (QAbstractTransition a) #

qAbstractTransitionFromPtr :: Ptr (TQAbstractTransition a) -> IO (QAbstractTransition a) #

qAbstractTransitionAddFinalizer :: QAbstractTransition a -> IO () #

withQListQAbstractTransitionResult :: IO (Ptr (TQListQAbstractTransition ())) -> IO [QAbstractTransition ()] #

qAbstractTransitionListFromPtrList :: [Ptr (TQAbstractTransition a)] -> IO [QAbstractTransition a] #

type QListQAbstractTransition a = Object (CQListQAbstractTransition a) #

type TQListQAbstractTransition a = CQListQAbstractTransition a #

data CQListQAbstractTransition a #

type QBasicMutex a = Object (CQBasicMutex a) #

type TQBasicMutex a = CQBasicMutex a #

data CQBasicMutex a #

qCast_QBasicMutex :: Object a -> IO (QBasicMutex ()) #

type QBasicMutexSc a = QBasicMutex (CQBasicMutexSc a) #

type TQBasicMutexSc a = TQBasicMutex (CQBasicMutexSc a) #

data CQBasicMutexSc a #

qCastList_QBasicMutex :: QqCastList_QBasicMutex a r => a -> r #

withQBasicMutexResult :: IO (Ptr (TQBasicMutex a)) -> IO (QBasicMutex a) #

type QVariantAnimation a = QAbstractAnimation (CQVariantAnimation a) #

type TQVariantAnimation a = TQAbstractAnimation (CQVariantAnimation a) #

data CQVariantAnimation a #

qCast_QVariantAnimation :: Object a -> IO (QVariantAnimation ()) #

type QVariantAnimationSc a = QVariantAnimation (CQVariantAnimationSc a) #

type TQVariantAnimationSc a = TQVariantAnimation (CQVariantAnimationSc a) #

data CQVariantAnimationSc a #

qCastList_QVariantAnimation :: QqCastList_QVariantAnimation a r => a -> r #

withQVariantAnimationResult :: IO (Ptr (TQVariantAnimation a)) -> IO (QVariantAnimation a) #

qVariantAnimationFromPtr :: Ptr (TQVariantAnimation a) -> IO (QVariantAnimation a) #

qVariantAnimationAddFinalizer :: QVariantAnimation a -> IO () #

type QAbstractListModel a = QAbstractItemModel (CQAbstractListModel a) #

type TQAbstractListModel a = TQAbstractItemModel (CQAbstractListModel a) #

data CQAbstractListModel a #

qCast_QAbstractListModel :: Object a -> IO (QAbstractListModel ()) #

type QAbstractListModelSc a = QAbstractListModel (CQAbstractListModelSc a) #

type TQAbstractListModelSc a = TQAbstractListModel (CQAbstractListModelSc a) #

data CQAbstractListModelSc a #

qCastList_QAbstractListModel :: QqCastList_QAbstractListModel a r => a -> r #

withQAbstractListModelResult :: IO (Ptr (TQAbstractListModel a)) -> IO (QAbstractListModel a) #

qAbstractListModelFromPtr :: Ptr (TQAbstractListModel a) -> IO (QAbstractListModel a) #

qAbstractListModelAddFinalizer :: QAbstractListModel a -> IO () #

type QState a = QAbstractState (CQState a) #

type TQState a = TQAbstractState (CQState a) #

data CQState a #

qCast_QState :: Object a -> IO (QState ()) #

type QStateSc a = QState (CQStateSc a) #

type TQStateSc a = TQState (CQStateSc a) #

data CQStateSc a #

qCastList_QState :: QqCastList_QState a r => a -> r #

withQStateResult :: IO (Ptr (TQState a)) -> IO (QState a) #

qStateFromPtr :: Ptr (TQState a) -> IO (QState a) #

qStateAddFinalizer :: QState a -> IO () #

type QFile a = QFileDevice (CQFile a) #

type TQFile a = TQFileDevice (CQFile a) #

data CQFile a #

qCast_QFile :: Object a -> IO (QFile ()) #

type QFileSc a = QFile (CQFileSc a) #

type TQFileSc a = TQFile (CQFileSc a) #

data CQFileSc a #

qCastList_QFile :: QqCastList_QFile a r => a -> r #

withQFileResult :: IO (Ptr (TQFile a)) -> IO (QFile a) #

qFileFromPtr :: Ptr (TQFile a) -> IO (QFile a) #

qFileAddFinalizer :: QFile a -> IO () #

type QString a = Object (CQString a) #

type TQString a = CQString a #

data CQString a #

qCast_QString :: Object a -> IO (QString ()) #

type QStringSc a = QString (CQStringSc a) #

type TQStringSc a = TQString (CQStringSc a) #

data CQStringSc a #

qCastList_QString :: QqCastList_QString a r => a -> r #

type QByteArrayMatcher a = Object (CQByteArrayMatcher a) #

type TQByteArrayMatcher a = CQByteArrayMatcher a #

data CQByteArrayMatcher a #

qCast_QByteArrayMatcher :: Object a -> IO (QByteArrayMatcher ()) #

type QByteArrayMatcherSc a = QByteArrayMatcher (CQByteArrayMatcherSc a) #

type TQByteArrayMatcherSc a = TQByteArrayMatcher (CQByteArrayMatcherSc a) #

data CQByteArrayMatcherSc a #

qCastList_QByteArrayMatcher :: QqCastList_QByteArrayMatcher a r => a -> r #

type QJsonValue a = Object (CQJsonValue a) #

type TQJsonValue a = CQJsonValue a #

data CQJsonValue a #

qCast_QJsonValue :: Object a -> IO (QJsonValue ()) #

type QJsonValueSc a = QJsonValue (CQJsonValueSc a) #

type TQJsonValueSc a = TQJsonValue (CQJsonValueSc a) #

data CQJsonValueSc a #

qCastList_QJsonValue :: QqCastList_QJsonValue a r => a -> r #

withQJsonValueResult :: IO (Ptr (TQJsonValue a)) -> IO (QJsonValue a) #

type QEventPrivate a = Object (CQEventPrivate a) #

type TQEventPrivate a = CQEventPrivate a #

data CQEventPrivate a #

qCast_QEventPrivate :: Object a -> IO (QEventPrivate ()) #

type QEventPrivateSc a = QEventPrivate (CQEventPrivateSc a) #

type TQEventPrivateSc a = TQEventPrivate (CQEventPrivateSc a) #

data CQEventPrivateSc a #

qCastList_QEventPrivate :: QqCastList_QEventPrivate a r => a -> r #

type QMimeDatabase a = Object (CQMimeDatabase a) #

type TQMimeDatabase a = CQMimeDatabase a #

data CQMimeDatabase a #

qCast_QMimeDatabase :: Object a -> IO (QMimeDatabase ()) #

type QMimeDatabaseSc a = QMimeDatabase (CQMimeDatabaseSc a) #

type TQMimeDatabaseSc a = TQMimeDatabase (CQMimeDatabaseSc a) #

data CQMimeDatabaseSc a #

qCastList_QMimeDatabase :: QqCastList_QMimeDatabase a r => a -> r #

withQMimeDatabaseResult :: IO (Ptr (TQMimeDatabase a)) -> IO (QMimeDatabase a) #

type QTextEncoder a = Object (CQTextEncoder a) #

type TQTextEncoder a = CQTextEncoder a #

data CQTextEncoder a #

qCast_QTextEncoder :: Object a -> IO (QTextEncoder ()) #

type QTextEncoderSc a = QTextEncoder (CQTextEncoderSc a) #

type TQTextEncoderSc a = TQTextEncoder (CQTextEncoderSc a) #

data CQTextEncoderSc a #

qCastList_QTextEncoder :: QqCastList_QTextEncoder a r => a -> r #

withQTextEncoderResult :: IO (Ptr (TQTextEncoder a)) -> IO (QTextEncoder a) #

type QByteRef a = Object (CQByteRef a) #

type TQByteRef a = CQByteRef a #

data CQByteRef a #

qCast_QByteRef :: Object a -> IO (QByteRef ()) #

type QByteRefSc a = QByteRef (CQByteRefSc a) #

type TQByteRefSc a = TQByteRef (CQByteRefSc a) #

data CQByteRefSc a #

qCastList_QByteRef :: QqCastList_QByteRef a r => a -> r #

type QXmlStreamAttributes a = Object (CQXmlStreamAttributes a) #

type TQXmlStreamAttributes a = CQXmlStreamAttributes a #

data CQXmlStreamAttributes a #

qCast_QXmlStreamAttributes :: Object a -> IO (QXmlStreamAttributes ()) #

type QXmlStreamAttributesSc a = QXmlStreamAttributes (CQXmlStreamAttributesSc a) #

type TQXmlStreamAttributesSc a = TQXmlStreamAttributes (CQXmlStreamAttributesSc a) #

data CQXmlStreamAttributesSc a #

qCastList_QXmlStreamAttributes :: QqCastList_QXmlStreamAttributes a r => a -> r #

withQXmlStreamAttributesResult :: IO (Ptr (TQXmlStreamAttributes a)) -> IO (QXmlStreamAttributes a) #

type QJsonArray a = Object (CQJsonArray a) #

type TQJsonArray a = CQJsonArray a #

data CQJsonArray a #

qCast_QJsonArray :: Object a -> IO (QJsonArray ()) #

type QJsonArraySc a = QJsonArray (CQJsonArraySc a) #

type TQJsonArraySc a = TQJsonArray (CQJsonArraySc a) #

data CQJsonArraySc a #

qCastList_QJsonArray :: QqCastList_QJsonArray a r => a -> r #

withQJsonArrayResult :: IO (Ptr (TQJsonArray a)) -> IO (QJsonArray a) #

type QString_Null a = Object (CQString_Null a) #

type TQString_Null a = CQString_Null a #

data CQString_Null a #

qCast_QString_Null :: Object a -> IO (QString_Null ()) #

type QString_NullSc a = QString_Null (CQString_NullSc a) #

type TQString_NullSc a = TQString_Null (CQString_NullSc a) #

data CQString_NullSc a #

qCastList_QString_Null :: QqCastList_QString_Null a r => a -> r #

type QMessageLogger a = Object (CQMessageLogger a) #

type TQMessageLogger a = CQMessageLogger a #

data CQMessageLogger a #

qCast_QMessageLogger :: Object a -> IO (QMessageLogger ()) #

type QMessageLoggerSc a = QMessageLogger (CQMessageLoggerSc a) #

type TQMessageLoggerSc a = TQMessageLogger (CQMessageLoggerSc a) #

data CQMessageLoggerSc a #

qCastList_QMessageLogger :: QqCastList_QMessageLogger a r => a -> r #

type QBasicTimer a = Object (CQBasicTimer a) #

type TQBasicTimer a = CQBasicTimer a #

data CQBasicTimer a #

qCast_QBasicTimer :: Object a -> IO (QBasicTimer ()) #

type QBasicTimerSc a = QBasicTimer (CQBasicTimerSc a) #

type TQBasicTimerSc a = TQBasicTimer (CQBasicTimerSc a) #

data CQBasicTimerSc a #

qCastList_QBasicTimer :: QqCastList_QBasicTimer a r => a -> r #

withQBasicTimerResult :: IO (Ptr (TQBasicTimer a)) -> IO (QBasicTimer a) #

type QByteArrayDataPtr a = Object (CQByteArrayDataPtr a) #

type TQByteArrayDataPtr a = CQByteArrayDataPtr a #

data CQByteArrayDataPtr a #

qCast_QByteArrayDataPtr :: Object a -> IO (QByteArrayDataPtr ()) #

type QByteArrayDataPtrSc a = QByteArrayDataPtr (CQByteArrayDataPtrSc a) #

type TQByteArrayDataPtrSc a = TQByteArrayDataPtr (CQByteArrayDataPtrSc a) #

data CQByteArrayDataPtrSc a #

qCastList_QByteArrayDataPtr :: QqCastList_QByteArrayDataPtr a r => a -> r #

type QXmlStreamEntityDeclaration a = Object (CQXmlStreamEntityDeclaration a) #

type TQXmlStreamEntityDeclaration a = CQXmlStreamEntityDeclaration a #

data CQXmlStreamEntityDeclaration a #

qCast_QXmlStreamEntityDeclaration :: Object a -> IO (QXmlStreamEntityDeclaration ()) #

type QXmlStreamEntityDeclarationSc a = QXmlStreamEntityDeclaration (CQXmlStreamEntityDeclarationSc a) #

type TQXmlStreamEntityDeclarationSc a = TQXmlStreamEntityDeclaration (CQXmlStreamEntityDeclarationSc a) #

data CQXmlStreamEntityDeclarationSc a #

qCastList_QXmlStreamEntityDeclaration :: QqCastList_QXmlStreamEntityDeclaration a r => a -> r #

withQXmlStreamEntityDeclarationResult :: IO (Ptr (TQXmlStreamEntityDeclaration a)) -> IO (QXmlStreamEntityDeclaration a) #

withQVectorQXmlStreamEntityDeclarationResult :: IO (Ptr (TQVectorQXmlStreamEntityDeclaration ())) -> IO [QXmlStreamEntityDeclaration ()] #

qXmlStreamEntityDeclarationVectorFromPtrList :: [Ptr (TQXmlStreamEntityDeclaration a)] -> IO [QXmlStreamEntityDeclaration a] #

type QVectorQXmlStreamEntityDeclaration a = Object (CQVectorQXmlStreamEntityDeclaration a) #

type TQVectorQXmlStreamEntityDeclaration a = CQVectorQXmlStreamEntityDeclaration a #

data CQVectorQXmlStreamEntityDeclaration a #

type QFlag a = Object (CQFlag a) #

type TQFlag a = CQFlag a #

data CQFlag a #

qCast_QFlag :: Object a -> IO (QFlag ()) #

type QFlagSc a = QFlag (CQFlagSc a) #

type TQFlagSc a = TQFlag (CQFlagSc a) #

data CQFlagSc a #

qCastList_QFlag :: QqCastList_QFlag a r => a -> r #

type QUrl a = Object (CQUrl a) #

type TQUrl a = CQUrl a #

data CQUrl a #

qCast_QUrl :: Object a -> IO (QUrl ()) #

type QUrlSc a = QUrl (CQUrlSc a) #

type TQUrlSc a = TQUrl (CQUrlSc a) #

data CQUrlSc a #

qCastList_QUrl :: QqCastList_QUrl a r => a -> r #

withQUrlResult :: IO (Ptr (TQUrl a)) -> IO (QUrl a) #

withQListQUrlResult :: IO (Ptr (TQListQUrl ())) -> IO [QUrl ()] #

qUrlListFromPtrList :: [Ptr (TQUrl a)] -> IO [QUrl a] #

type QListQUrl a = Object (CQListQUrl a) #

type TQListQUrl a = CQListQUrl a #

data CQListQUrl a #

type QMessageLogContext a = Object (CQMessageLogContext a) #

type TQMessageLogContext a = CQMessageLogContext a #

data CQMessageLogContext a #

qCast_QMessageLogContext :: Object a -> IO (QMessageLogContext ()) #

type QMessageLogContextSc a = QMessageLogContext (CQMessageLogContextSc a) #

type TQMessageLogContextSc a = TQMessageLogContext (CQMessageLogContextSc a) #

data CQMessageLogContextSc a #

qCastList_QMessageLogContext :: QqCastList_QMessageLogContext a r => a -> r #

withQMessageLogContextResult :: IO (Ptr (TQMessageLogContext a)) -> IO (QMessageLogContext a) #

type QXmlStreamNotationDeclaration a = Object (CQXmlStreamNotationDeclaration a) #

type TQXmlStreamNotationDeclaration a = CQXmlStreamNotationDeclaration a #

data CQXmlStreamNotationDeclaration a #

qCast_QXmlStreamNotationDeclaration :: Object a -> IO (QXmlStreamNotationDeclaration ()) #

type QXmlStreamNotationDeclarationSc a = QXmlStreamNotationDeclaration (CQXmlStreamNotationDeclarationSc a) #

type TQXmlStreamNotationDeclarationSc a = TQXmlStreamNotationDeclaration (CQXmlStreamNotationDeclarationSc a) #

data CQXmlStreamNotationDeclarationSc a #

qCastList_QXmlStreamNotationDeclaration :: QqCastList_QXmlStreamNotationDeclaration a r => a -> r #

withQXmlStreamNotationDeclarationResult :: IO (Ptr (TQXmlStreamNotationDeclaration a)) -> IO (QXmlStreamNotationDeclaration a) #

withQVectorQXmlStreamNotationDeclarationResult :: IO (Ptr (TQVectorQXmlStreamNotationDeclaration ())) -> IO [QXmlStreamNotationDeclaration ()] #

qXmlStreamNotationDeclarationVectorFromPtrList :: [Ptr (TQXmlStreamNotationDeclaration a)] -> IO [QXmlStreamNotationDeclaration a] #

type QVectorQXmlStreamNotationDeclaration a = Object (CQVectorQXmlStreamNotationDeclaration a) #

type TQVectorQXmlStreamNotationDeclaration a = CQVectorQXmlStreamNotationDeclaration a #

data CQVectorQXmlStreamNotationDeclaration a #

type QVariant_Private a = Object (CQVariant_Private a) #

type TQVariant_Private a = CQVariant_Private a #

data CQVariant_Private a #

qCast_QVariant_Private :: Object a -> IO (QVariant_Private ()) #

type QVariant_PrivateSc a = QVariant_Private (CQVariant_PrivateSc a) #

type TQVariant_PrivateSc a = TQVariant_Private (CQVariant_PrivateSc a) #

data CQVariant_PrivateSc a #

qCastList_QVariant_Private :: QqCastList_QVariant_Private a r => a -> r #

type QTextStream a = Object (CQTextStream a) #

type TQTextStream a = CQTextStream a #

data CQTextStream a #

qCast_QTextStream :: Object a -> IO (QTextStream ()) #

type QTextStreamSc a = QTextStream (CQTextStreamSc a) #

type TQTextStreamSc a = TQTextStream (CQTextStreamSc a) #

data CQTextStreamSc a #

qCastList_QTextStream :: QqCastList_QTextStream a r => a -> r #

withQTextStreamResult :: IO (Ptr (TQTextStream a)) -> IO (QTextStream a) #

type QSize a = Object (CQSize a) #

type TQSize a = CQSize a #

data CQSize a #

qCast_QSize :: Object a -> IO (QSize ()) #

type QSizeSc a = QSize (CQSizeSc a) #

type TQSizeSc a = TQSize (CQSizeSc a) #

data CQSizeSc a #

qCastList_QSize :: QqCastList_QSize a r => a -> r #

withQSizeResult :: IO (Ptr (TQSize a)) -> IO (QSize a) #

withQListQSizeResult :: IO (Ptr (TQListQSize ())) -> IO [QSize ()] #

qSizeListFromPtrList :: [Ptr (TQSize a)] -> IO [QSize a] #

type QListQSize a = Object (CQListQSize a) #

type TQListQSize a = CQListQSize a #

data CQListQSize a #

withQVectorQSizeResult :: IO (Ptr (TQVectorQSize ())) -> IO [QSize ()] #

qSizeVectorFromPtrList :: [Ptr (TQSize a)] -> IO [QSize a] #

type QVectorQSize a = Object (CQVectorQSize a) #

type TQVectorQSize a = CQVectorQSize a #

data CQVectorQSize a #

type QLine a = Object (CQLine a) #

type TQLine a = CQLine a #

data CQLine a #

qCast_QLine :: Object a -> IO (QLine ()) #

type QLineSc a = QLine (CQLineSc a) #

type TQLineSc a = TQLine (CQLineSc a) #

data CQLineSc a #

qCastList_QLine :: QqCastList_QLine a r => a -> r #

withQLineResult :: IO (Ptr (TQLine a)) -> IO (QLine a) #

type QRect a = Object (CQRect a) #

type TQRect a = CQRect a #

data CQRect a #

qCast_QRect :: Object a -> IO (QRect ()) #

type QRectSc a = QRect (CQRectSc a) #

type TQRectSc a = TQRect (CQRectSc a) #

data CQRectSc a #

qCastList_QRect :: QqCastList_QRect a r => a -> r #

withQRectResult :: IO (Ptr (TQRect a)) -> IO (QRect a) #

withQListQRectResult :: IO (Ptr (TQListQRect ())) -> IO [QRect ()] #

qRectListFromPtrList :: [Ptr (TQRect a)] -> IO [QRect a] #

type QListQRect a = Object (CQListQRect a) #

type TQListQRect a = CQListQRect a #

data CQListQRect a #

withQVectorQRectResult :: IO (Ptr (TQVectorQRect ())) -> IO [QRect ()] #

qRectVectorFromPtrList :: [Ptr (TQRect a)] -> IO [QRect a] #

type QVectorQRect a = Object (CQVectorQRect a) #

type TQVectorQRect a = CQVectorQRect a #

data CQVectorQRect a #

type QPersistentModelIndex a = Object (CQPersistentModelIndex a) #

type TQPersistentModelIndex a = CQPersistentModelIndex a #

data CQPersistentModelIndex a #

qCast_QPersistentModelIndex :: Object a -> IO (QPersistentModelIndex ()) #

type QPersistentModelIndexSc a = QPersistentModelIndex (CQPersistentModelIndexSc a) #

type TQPersistentModelIndexSc a = TQPersistentModelIndex (CQPersistentModelIndexSc a) #

data CQPersistentModelIndexSc a #

qCastList_QPersistentModelIndex :: QqCastList_QPersistentModelIndex a r => a -> r #

withQPersistentModelIndexResult :: IO (Ptr (TQPersistentModelIndex a)) -> IO (QPersistentModelIndex a) #

type QPointF a = Object (CQPointF a) #

type TQPointF a = CQPointF a #

data CQPointF a #

qCast_QPointF :: Object a -> IO (QPointF ()) #

type QPointFSc a = QPointF (CQPointFSc a) #

type TQPointFSc a = TQPointF (CQPointFSc a) #

data CQPointFSc a #

qCastList_QPointF :: QqCastList_QPointF a r => a -> r #

withQPointFResult :: IO (Ptr (TQPointF a)) -> IO (QPointF a) #

withQListQPointFResult :: IO (Ptr (TQListQPointF ())) -> IO [QPointF ()] #

qPointFListFromPtrList :: [Ptr (TQPointF a)] -> IO [QPointF a] #

type QListQPointF a = Object (CQListQPointF a) #

type TQListQPointF a = CQListQPointF a #

data CQListQPointF a #

withQVectorQPointFResult :: IO (Ptr (TQVectorQPointF ())) -> IO [QPointF ()] #

qPointFVectorFromPtrList :: [Ptr (TQPointF a)] -> IO [QPointF a] #

type QVectorQPointF a = Object (CQVectorQPointF a) #

type TQVectorQPointF a = CQVectorQPointF a #

data CQVectorQPointF a #

type QSharedData a = Object (CQSharedData a) #

type TQSharedData a = CQSharedData a #

data CQSharedData a #

qCast_QSharedData :: Object a -> IO (QSharedData ()) #

type QSharedDataSc a = QSharedData (CQSharedDataSc a) #

type TQSharedDataSc a = TQSharedData (CQSharedDataSc a) #

data CQSharedDataSc a #

qCastList_QSharedData :: QqCastList_QSharedData a r => a -> r #

withQSharedDataResult :: IO (Ptr (TQSharedData a)) -> IO (QSharedData a) #

type QRegularExpressionMatch a = Object (CQRegularExpressionMatch a) #

type TQRegularExpressionMatch a = CQRegularExpressionMatch a #

data CQRegularExpressionMatch a #

qCast_QRegularExpressionMatch :: Object a -> IO (QRegularExpressionMatch ()) #

type QRegularExpressionMatchSc a = QRegularExpressionMatch (CQRegularExpressionMatchSc a) #

type TQRegularExpressionMatchSc a = TQRegularExpressionMatch (CQRegularExpressionMatchSc a) #

data CQRegularExpressionMatchSc a #

qCastList_QRegularExpressionMatch :: QqCastList_QRegularExpressionMatch a r => a -> r #

withQRegularExpressionMatchResult :: IO (Ptr (TQRegularExpressionMatch a)) -> IO (QRegularExpressionMatch a) #

type QGenericArgument a = Object (CQGenericArgument a) #

type TQGenericArgument a = CQGenericArgument a #

data CQGenericArgument a #

qCast_QGenericArgument :: Object a -> IO (QGenericArgument ()) #

type QGenericArgumentSc a = QGenericArgument (CQGenericArgumentSc a) #

type TQGenericArgumentSc a = TQGenericArgument (CQGenericArgumentSc a) #

data CQGenericArgumentSc a #

qCastList_QGenericArgument :: QqCastList_QGenericArgument a r => a -> r #

type QVariantComparisonHelper a = Object (CQVariantComparisonHelper a) #

type TQVariantComparisonHelper a = CQVariantComparisonHelper a #

data CQVariantComparisonHelper a #

qCast_QVariantComparisonHelper :: Object a -> IO (QVariantComparisonHelper ()) #

type QVariantComparisonHelperSc a = QVariantComparisonHelper (CQVariantComparisonHelperSc a) #

type TQVariantComparisonHelperSc a = TQVariantComparisonHelper (CQVariantComparisonHelperSc a) #

data CQVariantComparisonHelperSc a #

qCastList_QVariantComparisonHelper :: QqCastList_QVariantComparisonHelper a r => a -> r #

withQVariantComparisonHelperResult :: IO (Ptr (TQVariantComparisonHelper a)) -> IO (QVariantComparisonHelper a) #

type QAtomicInt a = Object (CQAtomicInt a) #

type TQAtomicInt a = CQAtomicInt a #

data CQAtomicInt a #

qCast_QAtomicInt :: Object a -> IO (QAtomicInt ()) #

type QAtomicIntSc a = QAtomicInt (CQAtomicIntSc a) #

type TQAtomicIntSc a = TQAtomicInt (CQAtomicIntSc a) #

data CQAtomicIntSc a #

qCastList_QAtomicInt :: QqCastList_QAtomicInt a r => a -> r #

withQAtomicIntResult :: IO (Ptr (TQAtomicInt a)) -> IO (QAtomicInt a) #

type QEasingCurve a = Object (CQEasingCurve a) #

type TQEasingCurve a = CQEasingCurve a #

data CQEasingCurve a #

qCast_QEasingCurve :: Object a -> IO (QEasingCurve ()) #

type QEasingCurveSc a = QEasingCurve (CQEasingCurveSc a) #

type TQEasingCurveSc a = TQEasingCurve (CQEasingCurveSc a) #

data CQEasingCurveSc a #

qCastList_QEasingCurve :: QqCastList_QEasingCurve a r => a -> r #

withQEasingCurveResult :: IO (Ptr (TQEasingCurve a)) -> IO (QEasingCurve a) #

type QProcessEnvironment a = Object (CQProcessEnvironment a) #

type TQProcessEnvironment a = CQProcessEnvironment a #

data CQProcessEnvironment a #

qCast_QProcessEnvironment :: Object a -> IO (QProcessEnvironment ()) #

type QProcessEnvironmentSc a = QProcessEnvironment (CQProcessEnvironmentSc a) #

type TQProcessEnvironmentSc a = TQProcessEnvironment (CQProcessEnvironmentSc a) #

data CQProcessEnvironmentSc a #

qCastList_QProcessEnvironment :: QqCastList_QProcessEnvironment a r => a -> r #

withQProcessEnvironmentResult :: IO (Ptr (TQProcessEnvironment a)) -> IO (QProcessEnvironment a) #

type QUrlPrivate a = Object (CQUrlPrivate a) #

type TQUrlPrivate a = CQUrlPrivate a #

data CQUrlPrivate a #

qCast_QUrlPrivate :: Object a -> IO (QUrlPrivate ()) #

type QUrlPrivateSc a = QUrlPrivate (CQUrlPrivateSc a) #

type TQUrlPrivateSc a = TQUrlPrivate (CQUrlPrivateSc a) #

data CQUrlPrivateSc a #

qCastList_QUrlPrivate :: QqCastList_QUrlPrivate a r => a -> r #

type QMetaObject a = Object (CQMetaObject a) #

type TQMetaObject a = CQMetaObject a #

data CQMetaObject a #

qCast_QMetaObject :: Object a -> IO (QMetaObject ()) #

type QMetaObjectSc a = QMetaObject (CQMetaObjectSc a) #

type TQMetaObjectSc a = TQMetaObject (CQMetaObjectSc a) #

data CQMetaObjectSc a #

qCastList_QMetaObject :: QqCastList_QMetaObject a r => a -> r #

type QAbstractNativeEventFilter a = Object (CQAbstractNativeEventFilter a) #

type TQAbstractNativeEventFilter a = CQAbstractNativeEventFilter a #

data CQAbstractNativeEventFilter a #

qCast_QAbstractNativeEventFilter :: Object a -> IO (QAbstractNativeEventFilter ()) #

type QAbstractNativeEventFilterSc a = QAbstractNativeEventFilter (CQAbstractNativeEventFilterSc a) #

type TQAbstractNativeEventFilterSc a = TQAbstractNativeEventFilter (CQAbstractNativeEventFilterSc a) #

data CQAbstractNativeEventFilterSc a #

qCastList_QAbstractNativeEventFilter :: QqCastList_QAbstractNativeEventFilter a r => a -> r #

withQAbstractNativeEventFilterResult :: IO (Ptr (TQAbstractNativeEventFilter a)) -> IO (QAbstractNativeEventFilter a) #

type QMargins a = Object (CQMargins a) #

type TQMargins a = CQMargins a #

data CQMargins a #

qCast_QMargins :: Object a -> IO (QMargins ()) #

type QMarginsSc a = QMargins (CQMarginsSc a) #

type TQMarginsSc a = TQMargins (CQMarginsSc a) #

data CQMarginsSc a #

qCastList_QMargins :: QqCastList_QMargins a r => a -> r #

withQMarginsResult :: IO (Ptr (TQMargins a)) -> IO (QMargins a) #

type QSystemSemaphore a = Object (CQSystemSemaphore a) #

type TQSystemSemaphore a = CQSystemSemaphore a #

data CQSystemSemaphore a #

qCast_QSystemSemaphore :: Object a -> IO (QSystemSemaphore ()) #

type QSystemSemaphoreSc a = QSystemSemaphore (CQSystemSemaphoreSc a) #

type TQSystemSemaphoreSc a = TQSystemSemaphore (CQSystemSemaphoreSc a) #

data CQSystemSemaphoreSc a #

qCastList_QSystemSemaphore :: QqCastList_QSystemSemaphore a r => a -> r #

withQSystemSemaphoreResult :: IO (Ptr (TQSystemSemaphore a)) -> IO (QSystemSemaphore a) #

type QJsonValueRefPtr a = Object (CQJsonValueRefPtr a) #

type TQJsonValueRefPtr a = CQJsonValueRefPtr a #

data CQJsonValueRefPtr a #

qCast_QJsonValueRefPtr :: Object a -> IO (QJsonValueRefPtr ()) #

type QJsonValueRefPtrSc a = QJsonValueRefPtr (CQJsonValueRefPtrSc a) #

type TQJsonValueRefPtrSc a = TQJsonValueRefPtr (CQJsonValueRefPtrSc a) #

data CQJsonValueRefPtrSc a #

qCastList_QJsonValueRefPtr :: QqCastList_QJsonValueRefPtr a r => a -> r #

withQJsonValueRefPtrResult :: IO (Ptr (TQJsonValueRefPtr a)) -> IO (QJsonValueRefPtr a) #

type QStaticPlugin a = Object (CQStaticPlugin a) #

type TQStaticPlugin a = CQStaticPlugin a #

data CQStaticPlugin a #

qCast_QStaticPlugin :: Object a -> IO (QStaticPlugin ()) #

type QStaticPluginSc a = QStaticPlugin (CQStaticPluginSc a) #

type TQStaticPluginSc a = TQStaticPlugin (CQStaticPluginSc a) #

data CQStaticPluginSc a #

qCastList_QStaticPlugin :: QqCastList_QStaticPlugin a r => a -> r #

withQStaticPluginResult :: IO (Ptr (TQStaticPlugin a)) -> IO (QStaticPlugin a) #

withQVectorQStaticPluginResult :: IO (Ptr (TQVectorQStaticPlugin ())) -> IO [QStaticPlugin ()] #

qStaticPluginVectorFromPtrList :: [Ptr (TQStaticPlugin a)] -> IO [QStaticPlugin a] #

type QVectorQStaticPlugin a = Object (CQVectorQStaticPlugin a) #

type TQVectorQStaticPlugin a = CQVectorQStaticPlugin a #

data CQVectorQStaticPlugin a #

type QLocale a = Object (CQLocale a) #

type TQLocale a = CQLocale a #

data CQLocale a #

qCast_QLocale :: Object a -> IO (QLocale ()) #

type QLocaleSc a = QLocale (CQLocaleSc a) #

type TQLocaleSc a = TQLocale (CQLocaleSc a) #

data CQLocaleSc a #

qCastList_QLocale :: QqCastList_QLocale a r => a -> r #

withQLocaleResult :: IO (Ptr (TQLocale a)) -> IO (QLocale a) #

withQListQLocaleResult :: IO (Ptr (TQListQLocale ())) -> IO [QLocale ()] #

qLocaleListFromPtrList :: [Ptr (TQLocale a)] -> IO [QLocale a] #

type QListQLocale a = Object (CQListQLocale a) #

type TQListQLocale a = CQListQLocale a #

data CQListQLocale a #

withQVectorQLocaleResult :: IO (Ptr (TQVectorQLocale ())) -> IO [QLocale ()] #

qLocaleVectorFromPtrList :: [Ptr (TQLocale a)] -> IO [QLocale a] #

type QVectorQLocale a = Object (CQVectorQLocale a) #

type TQVectorQLocale a = CQVectorQLocale a #

data CQVectorQLocale a #

type QStringView a = Object (CQStringView a) #

type TQStringView a = CQStringView a #

data CQStringView a #

qCast_QStringView :: Object a -> IO (QStringView ()) #

type QStringViewSc a = QStringView (CQStringViewSc a) #

type TQStringViewSc a = TQStringView (CQStringViewSc a) #

data CQStringViewSc a #

qCastList_QStringView :: QqCastList_QStringView a r => a -> r #

withQStringViewResult :: IO (Ptr (TQStringView a)) -> IO (QStringView a) #

type QXmlStreamWriter a = Object (CQXmlStreamWriter a) #

type TQXmlStreamWriter a = CQXmlStreamWriter a #

data CQXmlStreamWriter a #

qCast_QXmlStreamWriter :: Object a -> IO (QXmlStreamWriter ()) #

type QXmlStreamWriterSc a = QXmlStreamWriter (CQXmlStreamWriterSc a) #

type TQXmlStreamWriterSc a = TQXmlStreamWriter (CQXmlStreamWriterSc a) #

data CQXmlStreamWriterSc a #

qCastList_QXmlStreamWriter :: QqCastList_QXmlStreamWriter a r => a -> r #

withQXmlStreamWriterResult :: IO (Ptr (TQXmlStreamWriter a)) -> IO (QXmlStreamWriter a) #

type QSizeF a = Object (CQSizeF a) #

type TQSizeF a = CQSizeF a #

data CQSizeF a #

qCast_QSizeF :: Object a -> IO (QSizeF ()) #

type QSizeFSc a = QSizeF (CQSizeFSc a) #

type TQSizeFSc a = TQSizeF (CQSizeFSc a) #

data CQSizeFSc a #

qCastList_QSizeF :: QqCastList_QSizeF a r => a -> r #

withQSizeFResult :: IO (Ptr (TQSizeF a)) -> IO (QSizeF a) #

type QStringList a = Object (CQStringList a) #

type TQStringList a = CQStringList a #

data CQStringList a #

qCast_QStringList :: Object a -> IO (QStringList ()) #

type QStringListSc a = QStringList (CQStringListSc a) #

type TQStringListSc a = TQStringList (CQStringListSc a) #

data CQStringListSc a #

qCastList_QStringList :: QqCastList_QStringList a r => a -> r #

type QTime a = Object (CQTime a) #

type TQTime a = CQTime a #

data CQTime a #

qCast_QTime :: Object a -> IO (QTime ()) #

type QTimeSc a = QTime (CQTimeSc a) #

type TQTimeSc a = TQTime (CQTimeSc a) #

data CQTimeSc a #

qCastList_QTime :: QqCastList_QTime a r => a -> r #

withQTimeResult :: IO (Ptr (TQTime a)) -> IO (QTime a) #

type QStringMatcher a = Object (CQStringMatcher a) #

type TQStringMatcher a = CQStringMatcher a #

data CQStringMatcher a #

qCast_QStringMatcher :: Object a -> IO (QStringMatcher ()) #

type QStringMatcherSc a = QStringMatcher (CQStringMatcherSc a) #

type TQStringMatcherSc a = TQStringMatcher (CQStringMatcherSc a) #

data CQStringMatcherSc a #

qCastList_QStringMatcher :: QqCastList_QStringMatcher a r => a -> r #

type QCharRef a = Object (CQCharRef a) #

type TQCharRef a = CQCharRef a #

data CQCharRef a #

qCast_QCharRef :: Object a -> IO (QCharRef ()) #

type QCharRefSc a = QCharRef (CQCharRefSc a) #

type TQCharRefSc a = TQCharRef (CQCharRefSc a) #

data CQCharRefSc a #

qCastList_QCharRef :: QqCastList_QCharRef a r => a -> r #

type QDataStream a = Object (CQDataStream a) #

type TQDataStream a = CQDataStream a #

data CQDataStream a #

qCast_QDataStream :: Object a -> IO (QDataStream ()) #

type QDataStreamSc a = QDataStream (CQDataStreamSc a) #

type TQDataStreamSc a = TQDataStream (CQDataStreamSc a) #

data CQDataStreamSc a #

qCastList_QDataStream :: QqCastList_QDataStream a r => a -> r #

withQDataStreamResult :: IO (Ptr (TQDataStream a)) -> IO (QDataStream a) #

type QTextDecoder a = Object (CQTextDecoder a) #

type TQTextDecoder a = CQTextDecoder a #

data CQTextDecoder a #

qCast_QTextDecoder :: Object a -> IO (QTextDecoder ()) #

type QTextDecoderSc a = QTextDecoder (CQTextDecoderSc a) #

type TQTextDecoderSc a = TQTextDecoder (CQTextDecoderSc a) #

data CQTextDecoderSc a #

qCastList_QTextDecoder :: QqCastList_QTextDecoder a r => a -> r #

withQTextDecoderResult :: IO (Ptr (TQTextDecoder a)) -> IO (QTextDecoder a) #

type QRectF a = Object (CQRectF a) #

type TQRectF a = CQRectF a #

data CQRectF a #

qCast_QRectF :: Object a -> IO (QRectF ()) #

type QRectFSc a = QRectF (CQRectFSc a) #

type TQRectFSc a = TQRectF (CQRectFSc a) #

data CQRectFSc a #

qCastList_QRectF :: QqCastList_QRectF a r => a -> r #

withQRectFResult :: IO (Ptr (TQRectF a)) -> IO (QRectF a) #

withQListQRectFResult :: IO (Ptr (TQListQRectF ())) -> IO [QRectF ()] #

qRectFListFromPtrList :: [Ptr (TQRectF a)] -> IO [QRectF a] #

type QListQRectF a = Object (CQListQRectF a) #

type TQListQRectF a = CQListQRectF a #

data CQListQRectF a #

type QAbstractEventDispatcher_TimerInfo a = Object (CQAbstractEventDispatcher_TimerInfo a) #

type TQAbstractEventDispatcher_TimerInfo a = CQAbstractEventDispatcher_TimerInfo a #

data CQAbstractEventDispatcher_TimerInfo a #

qCast_QAbstractEventDispatcher_TimerInfo :: Object a -> IO (QAbstractEventDispatcher_TimerInfo ()) #

type QAbstractEventDispatcher_TimerInfoSc a = QAbstractEventDispatcher_TimerInfo (CQAbstractEventDispatcher_TimerInfoSc a) #

type TQAbstractEventDispatcher_TimerInfoSc a = TQAbstractEventDispatcher_TimerInfo (CQAbstractEventDispatcher_TimerInfoSc a) #

data CQAbstractEventDispatcher_TimerInfoSc a #

qCastList_QAbstractEventDispatcher_TimerInfo :: QqCastList_QAbstractEventDispatcher_TimerInfo a r => a -> r #

withQAbstractEventDispatcher_TimerInfoResult :: IO (Ptr (TQAbstractEventDispatcher_TimerInfo a)) -> IO (QAbstractEventDispatcher_TimerInfo a) #

withQListQAbstractEventDispatcher_TimerInfoResult :: IO (Ptr (TQListQAbstractEventDispatcher_TimerInfo ())) -> IO [QAbstractEventDispatcher_TimerInfo ()] #

qAbstractEventDispatcher_TimerInfoListFromPtrList :: [Ptr (TQAbstractEventDispatcher_TimerInfo a)] -> IO [QAbstractEventDispatcher_TimerInfo a] #

type QListQAbstractEventDispatcher_TimerInfo a = Object (CQListQAbstractEventDispatcher_TimerInfo a) #

type TQListQAbstractEventDispatcher_TimerInfo a = CQListQAbstractEventDispatcher_TimerInfo a #

data CQListQAbstractEventDispatcher_TimerInfo a #

type QWaitCondition a = Object (CQWaitCondition a) #

type TQWaitCondition a = CQWaitCondition a #

data CQWaitCondition a #

qCast_QWaitCondition :: Object a -> IO (QWaitCondition ()) #

type QWaitConditionSc a = QWaitCondition (CQWaitConditionSc a) #

type TQWaitConditionSc a = TQWaitCondition (CQWaitConditionSc a) #

data CQWaitConditionSc a #

qCastList_QWaitCondition :: QqCastList_QWaitCondition a r => a -> r #

withQWaitConditionResult :: IO (Ptr (TQWaitCondition a)) -> IO (QWaitCondition a) #

type QLoggingCategory a = Object (CQLoggingCategory a) #

type TQLoggingCategory a = CQLoggingCategory a #

data CQLoggingCategory a #

qCast_QLoggingCategory :: Object a -> IO (QLoggingCategory ()) #

type QLoggingCategorySc a = QLoggingCategory (CQLoggingCategorySc a) #

type TQLoggingCategorySc a = TQLoggingCategory (CQLoggingCategorySc a) #

data CQLoggingCategorySc a #

qCastList_QLoggingCategory :: QqCastList_QLoggingCategory a r => a -> r #

withQLoggingCategoryResult :: IO (Ptr (TQLoggingCategory a)) -> IO (QLoggingCategory a) #

type QMetaClassInfo a = Object (CQMetaClassInfo a) #

type TQMetaClassInfo a = CQMetaClassInfo a #

data CQMetaClassInfo a #

qCast_QMetaClassInfo :: Object a -> IO (QMetaClassInfo ()) #

type QMetaClassInfoSc a = QMetaClassInfo (CQMetaClassInfoSc a) #

type TQMetaClassInfoSc a = TQMetaClassInfo (CQMetaClassInfoSc a) #

data CQMetaClassInfoSc a #

qCastList_QMetaClassInfo :: QqCastList_QMetaClassInfo a r => a -> r #

type QJsonArray_iterator a = Object (CQJsonArray_iterator a) #

type TQJsonArray_iterator a = CQJsonArray_iterator a #

data CQJsonArray_iterator a #

qCast_QJsonArray_iterator :: Object a -> IO (QJsonArray_iterator ()) #

type QJsonArray_iteratorSc a = QJsonArray_iterator (CQJsonArray_iteratorSc a) #

type TQJsonArray_iteratorSc a = TQJsonArray_iterator (CQJsonArray_iteratorSc a) #

data CQJsonArray_iteratorSc a #

qCastList_QJsonArray_iterator :: QqCastList_QJsonArray_iterator a r => a -> r #

withQJsonArray_iteratorResult :: IO (Ptr (TQJsonArray_iterator a)) -> IO (QJsonArray_iterator a) #

type QByteArray a = Object (CQByteArray a) #

type TQByteArray a = CQByteArray a #

data CQByteArray a #

qCast_QByteArray :: Object a -> IO (QByteArray ()) #

type QByteArraySc a = QByteArray (CQByteArraySc a) #

type TQByteArraySc a = TQByteArray (CQByteArraySc a) #

data CQByteArraySc a #

qCastList_QByteArray :: QqCastList_QByteArray a r => a -> r #

withQByteArrayResult :: IO (Ptr (TQByteArray a)) -> IO (QByteArray a) #

withQListQByteArrayResult :: IO (Ptr (TQListQByteArray ())) -> IO [QByteArray ()] #

qByteArrayListFromPtrList :: [Ptr (TQByteArray a)] -> IO [QByteArray a] #

type QListQByteArray a = Object (CQListQByteArray a) #

type TQListQByteArray a = CQListQByteArray a #

data CQListQByteArray a #

withQVectorQByteArrayResult :: IO (Ptr (TQVectorQByteArray ())) -> IO [QByteArray ()] #

qByteArrayVectorFromPtrList :: [Ptr (TQByteArray a)] -> IO [QByteArray a] #

type QVectorQByteArray a = Object (CQVectorQByteArray a) #

type TQVectorQByteArray a = CQVectorQByteArray a #

data CQVectorQByteArray a #

type QCryptographicHash a = Object (CQCryptographicHash a) #

type TQCryptographicHash a = CQCryptographicHash a #

data CQCryptographicHash a #

qCast_QCryptographicHash :: Object a -> IO (QCryptographicHash ()) #

type QCryptographicHashSc a = QCryptographicHash (CQCryptographicHashSc a) #

type TQCryptographicHashSc a = TQCryptographicHash (CQCryptographicHashSc a) #

data CQCryptographicHashSc a #

qCastList_QCryptographicHash :: QqCastList_QCryptographicHash a r => a -> r #

withQCryptographicHashResult :: IO (Ptr (TQCryptographicHash a)) -> IO (QCryptographicHash a) #

type QStandardPaths a = Object (CQStandardPaths a) #

type TQStandardPaths a = CQStandardPaths a #

data CQStandardPaths a #

qCast_QStandardPaths :: Object a -> IO (QStandardPaths ()) #

type QStandardPathsSc a = QStandardPaths (CQStandardPathsSc a) #

type TQStandardPathsSc a = TQStandardPaths (CQStandardPathsSc a) #

data CQStandardPathsSc a #

qCastList_QStandardPaths :: QqCastList_QStandardPaths a r => a -> r #

withQStandardPathsResult :: IO (Ptr (TQStandardPaths a)) -> IO (QStandardPaths a) #

type QMetaEnum a = Object (CQMetaEnum a) #

type TQMetaEnum a = CQMetaEnum a #

data CQMetaEnum a #

qCast_QMetaEnum :: Object a -> IO (QMetaEnum ()) #

type QMetaEnumSc a = QMetaEnum (CQMetaEnumSc a) #

type TQMetaEnumSc a = TQMetaEnum (CQMetaEnumSc a) #

data CQMetaEnumSc a #

qCastList_QMetaEnum :: QqCastList_QMetaEnum a r => a -> r #

type QJsonObject_const_iterator a = Object (CQJsonObject_const_iterator a) #

type TQJsonObject_const_iterator a = CQJsonObject_const_iterator a #

data CQJsonObject_const_iterator a #

qCast_QJsonObject_const_iterator :: Object a -> IO (QJsonObject_const_iterator ()) #

type QJsonObject_const_iteratorSc a = QJsonObject_const_iterator (CQJsonObject_const_iteratorSc a) #

type TQJsonObject_const_iteratorSc a = TQJsonObject_const_iterator (CQJsonObject_const_iteratorSc a) #

data CQJsonObject_const_iteratorSc a #

qCastList_QJsonObject_const_iterator :: QqCastList_QJsonObject_const_iterator a r => a -> r #

withQJsonObject_const_iteratorResult :: IO (Ptr (TQJsonObject_const_iterator a)) -> IO (QJsonObject_const_iterator a) #

type QJsonValueRef a = Object (CQJsonValueRef a) #

type TQJsonValueRef a = CQJsonValueRef a #

data CQJsonValueRef a #

qCast_QJsonValueRef :: Object a -> IO (QJsonValueRef ()) #

type QJsonValueRefSc a = QJsonValueRef (CQJsonValueRefSc a) #

type TQJsonValueRefSc a = TQJsonValueRef (CQJsonValueRefSc a) #

data CQJsonValueRefSc a #

qCastList_QJsonValueRef :: QqCastList_QJsonValueRef a r => a -> r #

withQJsonValueRefResult :: IO (Ptr (TQJsonValueRef a)) -> IO (QJsonValueRef a) #

type QSysInfo a = Object (CQSysInfo a) #

type TQSysInfo a = CQSysInfo a #

data CQSysInfo a #

qCast_QSysInfo :: Object a -> IO (QSysInfo ()) #

type QSysInfoSc a = QSysInfo (CQSysInfoSc a) #

type TQSysInfoSc a = TQSysInfo (CQSysInfoSc a) #

data CQSysInfoSc a #

qCastList_QSysInfo :: QqCastList_QSysInfo a r => a -> r #

withQSysInfoResult :: IO (Ptr (TQSysInfo a)) -> IO (QSysInfo a) #

type QXmlStreamAttribute a = Object (CQXmlStreamAttribute a) #

type TQXmlStreamAttribute a = CQXmlStreamAttribute a #

data CQXmlStreamAttribute a #

qCast_QXmlStreamAttribute :: Object a -> IO (QXmlStreamAttribute ()) #

type QXmlStreamAttributeSc a = QXmlStreamAttribute (CQXmlStreamAttributeSc a) #

type TQXmlStreamAttributeSc a = TQXmlStreamAttribute (CQXmlStreamAttributeSc a) #

data CQXmlStreamAttributeSc a #

qCastList_QXmlStreamAttribute :: QqCastList_QXmlStreamAttribute a r => a -> r #

withQXmlStreamAttributeResult :: IO (Ptr (TQXmlStreamAttribute a)) -> IO (QXmlStreamAttribute a) #

type QTextBoundaryFinder a = Object (CQTextBoundaryFinder a) #

type TQTextBoundaryFinder a = CQTextBoundaryFinder a #

data CQTextBoundaryFinder a #

qCast_QTextBoundaryFinder :: Object a -> IO (QTextBoundaryFinder ()) #

type QTextBoundaryFinderSc a = QTextBoundaryFinder (CQTextBoundaryFinderSc a) #

type TQTextBoundaryFinderSc a = TQTextBoundaryFinder (CQTextBoundaryFinderSc a) #

data CQTextBoundaryFinderSc a #

qCastList_QTextBoundaryFinder :: QqCastList_QTextBoundaryFinder a r => a -> r #

withQTextBoundaryFinderResult :: IO (Ptr (TQTextBoundaryFinder a)) -> IO (QTextBoundaryFinder a) #

type QVariant a = Object (CQVariant a) #

type TQVariant a = CQVariant a #

data CQVariant a #

qCast_QVariant :: Object a -> IO (QVariant ()) #

type QVariantSc a = QVariant (CQVariantSc a) #

type TQVariantSc a = TQVariant (CQVariantSc a) #

data CQVariantSc a #

qCastList_QVariant :: QqCastList_QVariant a r => a -> r #

withQVariantResult :: IO (Ptr (TQVariant a)) -> IO (QVariant a) #

withQListQVariantResult :: IO (Ptr (TQListQVariant ())) -> IO [QVariant ()] #

qVariantListFromPtrList :: [Ptr (TQVariant a)] -> IO [QVariant a] #

type QListQVariant a = Object (CQListQVariant a) #

type TQListQVariant a = CQListQVariant a #

data CQListQVariant a #

withQVectorQVariantResult :: IO (Ptr (TQVectorQVariant ())) -> IO [QVariant ()] #

qVariantVectorFromPtrList :: [Ptr (TQVariant a)] -> IO [QVariant a] #

type QVectorQVariant a = Object (CQVectorQVariant a) #

type TQVectorQVariant a = CQVectorQVariant a #

data CQVectorQVariant a #

type QResource a = Object (CQResource a) #

type TQResource a = CQResource a #

data CQResource a #

qCast_QResource :: Object a -> IO (QResource ()) #

type QResourceSc a = QResource (CQResourceSc a) #

type TQResourceSc a = TQResource (CQResourceSc a) #

data CQResourceSc a #

qCastList_QResource :: QqCastList_QResource a r => a -> r #

withQResourceResult :: IO (Ptr (TQResource a)) -> IO (QResource a) #

type QJsonDocument a = Object (CQJsonDocument a) #

type TQJsonDocument a = CQJsonDocument a #

data CQJsonDocument a #

qCast_QJsonDocument :: Object a -> IO (QJsonDocument ()) #

type QJsonDocumentSc a = QJsonDocument (CQJsonDocumentSc a) #

type TQJsonDocumentSc a = TQJsonDocument (CQJsonDocumentSc a) #

data CQJsonDocumentSc a #

qCastList_QJsonDocument :: QqCastList_QJsonDocument a r => a -> r #

withQJsonDocumentResult :: IO (Ptr (TQJsonDocument a)) -> IO (QJsonDocument a) #

type QXmlStreamNamespaceDeclaration a = Object (CQXmlStreamNamespaceDeclaration a) #

type TQXmlStreamNamespaceDeclaration a = CQXmlStreamNamespaceDeclaration a #

data CQXmlStreamNamespaceDeclaration a #

qCast_QXmlStreamNamespaceDeclaration :: Object a -> IO (QXmlStreamNamespaceDeclaration ()) #

type QXmlStreamNamespaceDeclarationSc a = QXmlStreamNamespaceDeclaration (CQXmlStreamNamespaceDeclarationSc a) #

type TQXmlStreamNamespaceDeclarationSc a = TQXmlStreamNamespaceDeclaration (CQXmlStreamNamespaceDeclarationSc a) #

data CQXmlStreamNamespaceDeclarationSc a #

qCastList_QXmlStreamNamespaceDeclaration :: QqCastList_QXmlStreamNamespaceDeclaration a r => a -> r #

withQXmlStreamNamespaceDeclarationResult :: IO (Ptr (TQXmlStreamNamespaceDeclaration a)) -> IO (QXmlStreamNamespaceDeclaration a) #

withQVectorQXmlStreamNamespaceDeclarationResult :: IO (Ptr (TQVectorQXmlStreamNamespaceDeclaration ())) -> IO [QXmlStreamNamespaceDeclaration ()] #

qXmlStreamNamespaceDeclarationVectorFromPtrList :: [Ptr (TQXmlStreamNamespaceDeclaration a)] -> IO [QXmlStreamNamespaceDeclaration a] #

type QVectorQXmlStreamNamespaceDeclaration a = Object (CQVectorQXmlStreamNamespaceDeclaration a) #

type TQVectorQXmlStreamNamespaceDeclaration a = CQVectorQXmlStreamNamespaceDeclaration a #

data CQVectorQXmlStreamNamespaceDeclaration a #

type QRunnable a = Object (CQRunnable a) #

type TQRunnable a = CQRunnable a #

data CQRunnable a #

qCast_QRunnable :: Object a -> IO (QRunnable ()) #

type QRunnableSc a = QRunnable (CQRunnableSc a) #

type TQRunnableSc a = TQRunnable (CQRunnableSc a) #

data CQRunnableSc a #

qCastList_QRunnable :: QqCastList_QRunnable a r => a -> r #

type QLibraryInfo a = Object (CQLibraryInfo a) #

type TQLibraryInfo a = CQLibraryInfo a #

data CQLibraryInfo a #

qCast_QLibraryInfo :: Object a -> IO (QLibraryInfo ()) #

type QLibraryInfoSc a = QLibraryInfo (CQLibraryInfoSc a) #

type TQLibraryInfoSc a = TQLibraryInfo (CQLibraryInfoSc a) #

data CQLibraryInfoSc a #

qCastList_QLibraryInfo :: QqCastList_QLibraryInfo a r => a -> r #

withQLibraryInfoResult :: IO (Ptr (TQLibraryInfo a)) -> IO (QLibraryInfo a) #

type QHashDummyValue a = Object (CQHashDummyValue a) #

type TQHashDummyValue a = CQHashDummyValue a #

data CQHashDummyValue a #

qCast_QHashDummyValue :: Object a -> IO (QHashDummyValue ()) #

type QHashDummyValueSc a = QHashDummyValue (CQHashDummyValueSc a) #

type TQHashDummyValueSc a = TQHashDummyValue (CQHashDummyValueSc a) #

data CQHashDummyValueSc a #

qCastList_QHashDummyValue :: QqCastList_QHashDummyValue a r => a -> r #

withQHashDummyValueResult :: IO (Ptr (TQHashDummyValue a)) -> IO (QHashDummyValue a) #

type QUrlQueryPrivate a = Object (CQUrlQueryPrivate a) #

type TQUrlQueryPrivate a = CQUrlQueryPrivate a #

data CQUrlQueryPrivate a #

qCast_QUrlQueryPrivate :: Object a -> IO (QUrlQueryPrivate ()) #

type QUrlQueryPrivateSc a = QUrlQueryPrivate (CQUrlQueryPrivateSc a) #

type TQUrlQueryPrivateSc a = TQUrlQueryPrivate (CQUrlQueryPrivateSc a) #

data CQUrlQueryPrivateSc a #

qCastList_QUrlQueryPrivate :: QqCastList_QUrlQueryPrivate a r => a -> r #

type QSemaphore a = Object (CQSemaphore a) #

type TQSemaphore a = CQSemaphore a #

data CQSemaphore a #

qCast_QSemaphore :: Object a -> IO (QSemaphore ()) #

type QSemaphoreSc a = QSemaphore (CQSemaphoreSc a) #

type TQSemaphoreSc a = TQSemaphore (CQSemaphoreSc a) #

data CQSemaphoreSc a #

qCastList_QSemaphore :: QqCastList_QSemaphore a r => a -> r #

withQSemaphoreResult :: IO (Ptr (TQSemaphore a)) -> IO (QSemaphore a) #

type QMetaProperty a = Object (CQMetaProperty a) #

type TQMetaProperty a = CQMetaProperty a #

data CQMetaProperty a #

qCast_QMetaProperty :: Object a -> IO (QMetaProperty ()) #

type QMetaPropertySc a = QMetaProperty (CQMetaPropertySc a) #

type TQMetaPropertySc a = TQMetaProperty (CQMetaPropertySc a) #

data CQMetaPropertySc a #

qCastList_QMetaProperty :: QqCastList_QMetaProperty a r => a -> r #

withQMetaPropertyResult :: IO (Ptr (TQMetaProperty a)) -> IO (QMetaProperty a) #

type QRegularExpression a = Object (CQRegularExpression a) #

type TQRegularExpression a = CQRegularExpression a #

data CQRegularExpression a #

qCast_QRegularExpression :: Object a -> IO (QRegularExpression ()) #

type QRegularExpressionSc a = QRegularExpression (CQRegularExpressionSc a) #

type TQRegularExpressionSc a = TQRegularExpression (CQRegularExpressionSc a) #

data CQRegularExpressionSc a #

qCastList_QRegularExpression :: QqCastList_QRegularExpression a r => a -> r #

withQRegularExpressionResult :: IO (Ptr (TQRegularExpression a)) -> IO (QRegularExpression a) #

type QDebug a = Object (CQDebug a) #

type TQDebug a = CQDebug a #

data CQDebug a #

qCast_QDebug :: Object a -> IO (QDebug ()) #

type QDebugSc a = QDebug (CQDebugSc a) #

type TQDebugSc a = TQDebug (CQDebugSc a) #

data CQDebugSc a #

qCastList_QDebug :: QqCastList_QDebug a r => a -> r #

withQDebugResult :: IO (Ptr (TQDebug a)) -> IO (QDebug a) #

type QModelIndex a = Object (CQModelIndex a) #

type TQModelIndex a = CQModelIndex a #

data CQModelIndex a #

qCast_QModelIndex :: Object a -> IO (QModelIndex ()) #

type QModelIndexSc a = QModelIndex (CQModelIndexSc a) #

type TQModelIndexSc a = TQModelIndex (CQModelIndexSc a) #

data CQModelIndexSc a #

qCastList_QModelIndex :: QqCastList_QModelIndex a r => a -> r #

withQModelIndexResult :: IO (Ptr (TQModelIndex a)) -> IO (QModelIndex a) #

withQListQModelIndexResult :: IO (Ptr (TQListQModelIndex ())) -> IO [QModelIndex ()] #

qModelIndexListFromPtrList :: [Ptr (TQModelIndex a)] -> IO [QModelIndex a] #

type QListQModelIndex a = Object (CQListQModelIndex a) #

type TQListQModelIndex a = CQListQModelIndex a #

data CQListQModelIndex a #

type QIncompatibleFlag a = Object (CQIncompatibleFlag a) #

type TQIncompatibleFlag a = CQIncompatibleFlag a #

data CQIncompatibleFlag a #

qCast_QIncompatibleFlag :: Object a -> IO (QIncompatibleFlag ()) #

type QIncompatibleFlagSc a = QIncompatibleFlag (CQIncompatibleFlagSc a) #

type TQIncompatibleFlagSc a = TQIncompatibleFlag (CQIncompatibleFlagSc a) #

data CQIncompatibleFlagSc a #

qCastList_QIncompatibleFlag :: QqCastList_QIncompatibleFlag a r => a -> r #

withQIncompatibleFlagResult :: IO (Ptr (TQIncompatibleFlag a)) -> IO (QIncompatibleFlag a) #

type QCommandLineOption a = Object (CQCommandLineOption a) #

type TQCommandLineOption a = CQCommandLineOption a #

data CQCommandLineOption a #

qCast_QCommandLineOption :: Object a -> IO (QCommandLineOption ()) #

type QCommandLineOptionSc a = QCommandLineOption (CQCommandLineOptionSc a) #

type TQCommandLineOptionSc a = TQCommandLineOption (CQCommandLineOptionSc a) #

data CQCommandLineOptionSc a #

qCastList_QCommandLineOption :: QqCastList_QCommandLineOption a r => a -> r #

withQCommandLineOptionResult :: IO (Ptr (TQCommandLineOption a)) -> IO (QCommandLineOption a) #

type QReadLocker a = Object (CQReadLocker a) #

type TQReadLocker a = CQReadLocker a #

data CQReadLocker a #

qCast_QReadLocker :: Object a -> IO (QReadLocker ()) #

type QReadLockerSc a = QReadLocker (CQReadLockerSc a) #

type TQReadLockerSc a = TQReadLocker (CQReadLockerSc a) #

data CQReadLockerSc a #

qCastList_QReadLocker :: QqCastList_QReadLocker a r => a -> r #

withQReadLockerResult :: IO (Ptr (TQReadLocker a)) -> IO (QReadLocker a) #

type QMimeType a = Object (CQMimeType a) #

type TQMimeType a = CQMimeType a #

data CQMimeType a #

qCast_QMimeType :: Object a -> IO (QMimeType ()) #

type QMimeTypeSc a = QMimeType (CQMimeTypeSc a) #

type TQMimeTypeSc a = TQMimeType (CQMimeTypeSc a) #

data CQMimeTypeSc a #

qCastList_QMimeType :: QqCastList_QMimeType a r => a -> r #

withQMimeTypeResult :: IO (Ptr (TQMimeType a)) -> IO (QMimeType a) #

withQListQMimeTypeResult :: IO (Ptr (TQListQMimeType ())) -> IO [QMimeType ()] #

qMimeTypeListFromPtrList :: [Ptr (TQMimeType a)] -> IO [QMimeType a] #

type QListQMimeType a = Object (CQListQMimeType a) #

type TQListQMimeType a = CQListQMimeType a #

data CQListQMimeType a #

type QTimeZone_OffsetData a = Object (CQTimeZone_OffsetData a) #

type TQTimeZone_OffsetData a = CQTimeZone_OffsetData a #

data CQTimeZone_OffsetData a #

qCast_QTimeZone_OffsetData :: Object a -> IO (QTimeZone_OffsetData ()) #

type QTimeZone_OffsetDataSc a = QTimeZone_OffsetData (CQTimeZone_OffsetDataSc a) #

type TQTimeZone_OffsetDataSc a = TQTimeZone_OffsetData (CQTimeZone_OffsetDataSc a) #

data CQTimeZone_OffsetDataSc a #

qCastList_QTimeZone_OffsetData :: QqCastList_QTimeZone_OffsetData a r => a -> r #

withQTimeZone_OffsetDataResult :: IO (Ptr (TQTimeZone_OffsetData a)) -> IO (QTimeZone_OffsetData a) #

withQVectorQTimeZone_OffsetDataResult :: IO (Ptr (TQVectorQTimeZone_OffsetData ())) -> IO [QTimeZone_OffsetData ()] #

qTimeZone_OffsetDataVectorFromPtrList :: [Ptr (TQTimeZone_OffsetData a)] -> IO [QTimeZone_OffsetData a] #

type QVectorQTimeZone_OffsetData a = Object (CQVectorQTimeZone_OffsetData a) #

type TQVectorQTimeZone_OffsetData a = CQVectorQTimeZone_OffsetData a #

data CQVectorQTimeZone_OffsetData a #

type QStorageInfo a = Object (CQStorageInfo a) #

type TQStorageInfo a = CQStorageInfo a #

data CQStorageInfo a #

qCast_QStorageInfo :: Object a -> IO (QStorageInfo ()) #

type QStorageInfoSc a = QStorageInfo (CQStorageInfoSc a) #

type TQStorageInfoSc a = TQStorageInfo (CQStorageInfoSc a) #

data CQStorageInfoSc a #

qCastList_QStorageInfo :: QqCastList_QStorageInfo a r => a -> r #

withQStorageInfoResult :: IO (Ptr (TQStorageInfo a)) -> IO (QStorageInfo a) #

withQListQStorageInfoResult :: IO (Ptr (TQListQStorageInfo ())) -> IO [QStorageInfo ()] #

qStorageInfoListFromPtrList :: [Ptr (TQStorageInfo a)] -> IO [QStorageInfo a] #

type QListQStorageInfo a = Object (CQListQStorageInfo a) #

type TQListQStorageInfo a = CQListQStorageInfo a #

data CQListQStorageInfo a #

type QTextCodec a = Object (CQTextCodec a) #

type TQTextCodec a = CQTextCodec a #

data CQTextCodec a #

qCast_QTextCodec :: Object a -> IO (QTextCodec ()) #

type QTextCodecSc a = QTextCodec (CQTextCodecSc a) #

type TQTextCodecSc a = TQTextCodec (CQTextCodecSc a) #

data CQTextCodecSc a #

qCastList_QTextCodec :: QqCastList_QTextCodec a r => a -> r #

withQTextCodecResult :: IO (Ptr (TQTextCodec a)) -> IO (QTextCodec a) #

type QLatin1String a = Object (CQLatin1String a) #

type TQLatin1String a = CQLatin1String a #

data CQLatin1String a #

qCast_QLatin1String :: Object a -> IO (QLatin1String ()) #

type QLatin1StringSc a = QLatin1String (CQLatin1StringSc a) #

type TQLatin1StringSc a = TQLatin1String (CQLatin1StringSc a) #

data CQLatin1StringSc a #

qCastList_QLatin1String :: QqCastList_QLatin1String a r => a -> r #

type QStringRef a = Object (CQStringRef a) #

type TQStringRef a = CQStringRef a #

data CQStringRef a #

qCast_QStringRef :: Object a -> IO (QStringRef ()) #

type QStringRefSc a = QStringRef (CQStringRefSc a) #

type TQStringRefSc a = TQStringRef (CQStringRefSc a) #

data CQStringRefSc a #

qCastList_QStringRef :: QqCastList_QStringRef a r => a -> r #

type QDateTime a = Object (CQDateTime a) #

type TQDateTime a = CQDateTime a #

data CQDateTime a #

qCast_QDateTime :: Object a -> IO (QDateTime ()) #

type QDateTimeSc a = QDateTime (CQDateTimeSc a) #

type TQDateTimeSc a = TQDateTime (CQDateTimeSc a) #

data CQDateTimeSc a #

qCastList_QDateTime :: QqCastList_QDateTime a r => a -> r #

withQDateTimeResult :: IO (Ptr (TQDateTime a)) -> IO (QDateTime a) #

type QTextStreamManipulator a = Object (CQTextStreamManipulator a) #

type TQTextStreamManipulator a = CQTextStreamManipulator a #

data CQTextStreamManipulator a #

qCast_QTextStreamManipulator :: Object a -> IO (QTextStreamManipulator ()) #

type QTextStreamManipulatorSc a = QTextStreamManipulator (CQTextStreamManipulatorSc a) #

type TQTextStreamManipulatorSc a = TQTextStreamManipulator (CQTextStreamManipulatorSc a) #

data CQTextStreamManipulatorSc a #

qCastList_QTextStreamManipulator :: QqCastList_QTextStreamManipulator a r => a -> r #

withQTextStreamManipulatorResult :: IO (Ptr (TQTextStreamManipulator a)) -> IO (QTextStreamManipulator a) #

type QMetaMethod a = Object (CQMetaMethod a) #

type TQMetaMethod a = CQMetaMethod a #

data CQMetaMethod a #

qCast_QMetaMethod :: Object a -> IO (QMetaMethod ()) #

type QMetaMethodSc a = QMetaMethod (CQMetaMethodSc a) #

type TQMetaMethodSc a = TQMetaMethod (CQMetaMethodSc a) #

data CQMetaMethodSc a #

qCastList_QMetaMethod :: QqCastList_QMetaMethod a r => a -> r #

withQMetaMethodResult :: IO (Ptr (TQMetaMethod a)) -> IO (QMetaMethod a) #

type Qfloat16 a = Object (CQfloat16 a) #

type TQfloat16 a = CQfloat16 a #

data CQfloat16 a #

qCast_Qfloat16 :: Object a -> IO (Qfloat16 ()) #

type Qfloat16Sc a = Qfloat16 (CQfloat16Sc a) #

type TQfloat16Sc a = TQfloat16 (CQfloat16Sc a) #

data CQfloat16Sc a #

qCastList_Qfloat16 :: QqCastList_Qfloat16 a r => a -> r #

withQfloat16Result :: IO (Ptr (TQfloat16 a)) -> IO (Qfloat16 a) #

type QEventLoopLocker a = Object (CQEventLoopLocker a) #

type TQEventLoopLocker a = CQEventLoopLocker a #

data CQEventLoopLocker a #

qCast_QEventLoopLocker :: Object a -> IO (QEventLoopLocker ()) #

type QEventLoopLockerSc a = QEventLoopLocker (CQEventLoopLockerSc a) #

type TQEventLoopLockerSc a = TQEventLoopLocker (CQEventLoopLockerSc a) #

data CQEventLoopLockerSc a #

qCastList_QEventLoopLocker :: QqCastList_QEventLoopLocker a r => a -> r #

withQEventLoopLockerResult :: IO (Ptr (TQEventLoopLocker a)) -> IO (QEventLoopLocker a) #

type QElapsedTimer a = Object (CQElapsedTimer a) #

type TQElapsedTimer a = CQElapsedTimer a #

data CQElapsedTimer a #

qCast_QElapsedTimer :: Object a -> IO (QElapsedTimer ()) #

type QElapsedTimerSc a = QElapsedTimer (CQElapsedTimerSc a) #

type TQElapsedTimerSc a = TQElapsedTimer (CQElapsedTimerSc a) #

data CQElapsedTimerSc a #

qCastList_QElapsedTimer :: QqCastList_QElapsedTimer a r => a -> r #

withQElapsedTimerResult :: IO (Ptr (TQElapsedTimer a)) -> IO (QElapsedTimer a) #

type QItemSelection a = Object (CQItemSelection a) #

type TQItemSelection a = CQItemSelection a #

data CQItemSelection a #

qCast_QItemSelection :: Object a -> IO (QItemSelection ()) #

type QItemSelectionSc a = QItemSelection (CQItemSelectionSc a) #

type TQItemSelectionSc a = TQItemSelection (CQItemSelectionSc a) #

data CQItemSelectionSc a #

qCastList_QItemSelection :: QqCastList_QItemSelection a r => a -> r #

withQItemSelectionResult :: IO (Ptr (TQItemSelection a)) -> IO (QItemSelection a) #

type QVersionNumber a = Object (CQVersionNumber a) #

type TQVersionNumber a = CQVersionNumber a #

data CQVersionNumber a #

qCast_QVersionNumber :: Object a -> IO (QVersionNumber ()) #

type QVersionNumberSc a = QVersionNumber (CQVersionNumberSc a) #

type TQVersionNumberSc a = TQVersionNumber (CQVersionNumberSc a) #

data CQVersionNumberSc a #

qCastList_QVersionNumber :: QqCastList_QVersionNumber a r => a -> r #

withQVersionNumberResult :: IO (Ptr (TQVersionNumber a)) -> IO (QVersionNumber a) #

type QTemporaryDir a = Object (CQTemporaryDir a) #

type TQTemporaryDir a = CQTemporaryDir a #

data CQTemporaryDir a #

qCast_QTemporaryDir :: Object a -> IO (QTemporaryDir ()) #

type QTemporaryDirSc a = QTemporaryDir (CQTemporaryDirSc a) #

type TQTemporaryDirSc a = TQTemporaryDir (CQTemporaryDirSc a) #

data CQTemporaryDirSc a #

qCastList_QTemporaryDir :: QqCastList_QTemporaryDir a r => a -> r #

withQTemporaryDirResult :: IO (Ptr (TQTemporaryDir a)) -> IO (QTemporaryDir a) #

type QUuid a = Object (CQUuid a) #

type TQUuid a = CQUuid a #

data CQUuid a #

qCast_QUuid :: Object a -> IO (QUuid ()) #

type QUuidSc a = QUuid (CQUuidSc a) #

type TQUuidSc a = TQUuid (CQUuidSc a) #

data CQUuidSc a #

qCastList_QUuid :: QqCastList_QUuid a r => a -> r #

withQUuidResult :: IO (Ptr (TQUuid a)) -> IO (QUuid a) #

type QLineF a = Object (CQLineF a) #

type TQLineF a = CQLineF a #

data CQLineF a #

qCast_QLineF :: Object a -> IO (QLineF ()) #

type QLineFSc a = QLineF (CQLineFSc a) #

type TQLineFSc a = TQLineF (CQLineFSc a) #

data CQLineFSc a #

qCastList_QLineF :: QqCastList_QLineF a r => a -> r #

withQLineFResult :: IO (Ptr (TQLineF a)) -> IO (QLineF a) #

type QWriteLocker a = Object (CQWriteLocker a) #

type TQWriteLocker a = CQWriteLocker a #

data CQWriteLocker a #

qCast_QWriteLocker :: Object a -> IO (QWriteLocker ()) #

type QWriteLockerSc a = QWriteLocker (CQWriteLockerSc a) #

type TQWriteLockerSc a = TQWriteLocker (CQWriteLockerSc a) #

data CQWriteLockerSc a #

qCastList_QWriteLocker :: QqCastList_QWriteLocker a r => a -> r #

withQWriteLockerResult :: IO (Ptr (TQWriteLocker a)) -> IO (QWriteLocker a) #

type QBitArray a = Object (CQBitArray a) #

type TQBitArray a = CQBitArray a #

data CQBitArray a #

qCast_QBitArray :: Object a -> IO (QBitArray ()) #

type QBitArraySc a = QBitArray (CQBitArraySc a) #

type TQBitArraySc a = TQBitArray (CQBitArraySc a) #

data CQBitArraySc a #

qCastList_QBitArray :: QqCastList_QBitArray a r => a -> r #

withQBitArrayResult :: IO (Ptr (TQBitArray a)) -> IO (QBitArray a) #

type QMutexLocker a = Object (CQMutexLocker a) #

type TQMutexLocker a = CQMutexLocker a #

data CQMutexLocker a #

qCast_QMutexLocker :: Object a -> IO (QMutexLocker ()) #

type QMutexLockerSc a = QMutexLocker (CQMutexLockerSc a) #

type TQMutexLockerSc a = TQMutexLocker (CQMutexLockerSc a) #

data CQMutexLockerSc a #

qCastList_QMutexLocker :: QqCastList_QMutexLocker a r => a -> r #

withQMutexLockerResult :: IO (Ptr (TQMutexLocker a)) -> IO (QMutexLocker a) #

type QFileInfo a = Object (CQFileInfo a) #

type TQFileInfo a = CQFileInfo a #

data CQFileInfo a #

qCast_QFileInfo :: Object a -> IO (QFileInfo ()) #

type QFileInfoSc a = QFileInfo (CQFileInfoSc a) #

type TQFileInfoSc a = TQFileInfo (CQFileInfoSc a) #

data CQFileInfoSc a #

qCastList_QFileInfo :: QqCastList_QFileInfo a r => a -> r #

withQFileInfoResult :: IO (Ptr (TQFileInfo a)) -> IO (QFileInfo a) #

withQListQFileInfoResult :: IO (Ptr (TQListQFileInfo ())) -> IO [QFileInfo ()] #

qFileInfoListFromPtrList :: [Ptr (TQFileInfo a)] -> IO [QFileInfo a] #

type QListQFileInfo a = Object (CQListQFileInfo a) #

type TQListQFileInfo a = CQListQFileInfo a #

data CQListQFileInfo a #

type QReadWriteLock a = Object (CQReadWriteLock a) #

type TQReadWriteLock a = CQReadWriteLock a #

data CQReadWriteLock a #

qCast_QReadWriteLock :: Object a -> IO (QReadWriteLock ()) #

type QReadWriteLockSc a = QReadWriteLock (CQReadWriteLockSc a) #

type TQReadWriteLockSc a = TQReadWriteLock (CQReadWriteLockSc a) #

data CQReadWriteLockSc a #

qCastList_QReadWriteLock :: QqCastList_QReadWriteLock a r => a -> r #

withQReadWriteLockResult :: IO (Ptr (TQReadWriteLock a)) -> IO (QReadWriteLock a) #

type Qt a = Object (CQt a) #

type TQt a = CQt a #

data CQt a #

qCast_Qt :: Object a -> IO (Qt ()) #

type QtSc a = Qt (CQtSc a) #

type TQtSc a = TQt (CQtSc a) #

data CQtSc a #

qCastList_Qt :: QqCastList_Qt a r => a -> r #

withQtResult :: IO (Ptr (TQt a)) -> IO (Qt a) #

type QJsonValuePtr a = Object (CQJsonValuePtr a) #

type TQJsonValuePtr a = CQJsonValuePtr a #

data CQJsonValuePtr a #

qCast_QJsonValuePtr :: Object a -> IO (QJsonValuePtr ()) #

type QJsonValuePtrSc a = QJsonValuePtr (CQJsonValuePtrSc a) #

type TQJsonValuePtrSc a = TQJsonValuePtr (CQJsonValuePtrSc a) #

data CQJsonValuePtrSc a #

qCastList_QJsonValuePtr :: QqCastList_QJsonValuePtr a r => a -> r #

type QPoint a = Object (CQPoint a) #

type TQPoint a = CQPoint a #

data CQPoint a #

qCast_QPoint :: Object a -> IO (QPoint ()) #

type QPointSc a = QPoint (CQPointSc a) #

type TQPointSc a = TQPoint (CQPointSc a) #

data CQPointSc a #

qCastList_QPoint :: QqCastList_QPoint a r => a -> r #

withQPointResult :: IO (Ptr (TQPoint a)) -> IO (QPoint a) #

type QUrlQuery a = Object (CQUrlQuery a) #

type TQUrlQuery a = CQUrlQuery a #

data CQUrlQuery a #

qCast_QUrlQuery :: Object a -> IO (QUrlQuery ()) #

type QUrlQuerySc a = QUrlQuery (CQUrlQuerySc a) #

type TQUrlQuerySc a = TQUrlQuery (CQUrlQuerySc a) #

data CQUrlQuerySc a #

qCastList_QUrlQuery :: QqCastList_QUrlQuery a r => a -> r #

withQUrlQueryResult :: IO (Ptr (TQUrlQuery a)) -> IO (QUrlQuery a) #

type QRegularExpressionMatchIterator a = Object (CQRegularExpressionMatchIterator a) #

type TQRegularExpressionMatchIterator a = CQRegularExpressionMatchIterator a #

data CQRegularExpressionMatchIterator a #

qCast_QRegularExpressionMatchIterator :: Object a -> IO (QRegularExpressionMatchIterator ()) #

type QRegularExpressionMatchIteratorSc a = QRegularExpressionMatchIterator (CQRegularExpressionMatchIteratorSc a) #

type TQRegularExpressionMatchIteratorSc a = TQRegularExpressionMatchIterator (CQRegularExpressionMatchIteratorSc a) #

data CQRegularExpressionMatchIteratorSc a #

qCastList_QRegularExpressionMatchIterator :: QqCastList_QRegularExpressionMatchIterator a r => a -> r #

withQRegularExpressionMatchIteratorResult :: IO (Ptr (TQRegularExpressionMatchIterator a)) -> IO (QRegularExpressionMatchIterator a) #

type QPostEventList a = Object (CQPostEventList a) #

type TQPostEventList a = CQPostEventList a #

data CQPostEventList a #

qCast_QPostEventList :: Object a -> IO (QPostEventList ()) #

type QPostEventListSc a = QPostEventList (CQPostEventListSc a) #

type TQPostEventListSc a = TQPostEventList (CQPostEventListSc a) #

data CQPostEventListSc a #

qCastList_QPostEventList :: QqCastList_QPostEventList a r => a -> r #

withQPostEventListResult :: IO (Ptr (TQPostEventList a)) -> IO (QPostEventList a) #

type QItemSelectionRange a = Object (CQItemSelectionRange a) #

type TQItemSelectionRange a = CQItemSelectionRange a #

data CQItemSelectionRange a #

qCast_QItemSelectionRange :: Object a -> IO (QItemSelectionRange ()) #

type QItemSelectionRangeSc a = QItemSelectionRange (CQItemSelectionRangeSc a) #

type TQItemSelectionRangeSc a = TQItemSelectionRange (CQItemSelectionRangeSc a) #

data CQItemSelectionRangeSc a #

qCastList_QItemSelectionRange :: QqCastList_QItemSelectionRange a r => a -> r #

withQItemSelectionRangeResult :: IO (Ptr (TQItemSelectionRange a)) -> IO (QItemSelectionRange a) #

type QXmlStreamReader a = Object (CQXmlStreamReader a) #

type TQXmlStreamReader a = CQXmlStreamReader a #

data CQXmlStreamReader a #

qCast_QXmlStreamReader :: Object a -> IO (QXmlStreamReader ()) #

type QXmlStreamReaderSc a = QXmlStreamReader (CQXmlStreamReaderSc a) #

type TQXmlStreamReaderSc a = TQXmlStreamReader (CQXmlStreamReaderSc a) #

data CQXmlStreamReaderSc a #

qCastList_QXmlStreamReader :: QqCastList_QXmlStreamReader a r => a -> r #

withQXmlStreamReaderResult :: IO (Ptr (TQXmlStreamReader a)) -> IO (QXmlStreamReader a) #

type QLatin1Char a = Object (CQLatin1Char a) #

type TQLatin1Char a = CQLatin1Char a #

data CQLatin1Char a #

qCast_QLatin1Char :: Object a -> IO (QLatin1Char ()) #

type QLatin1CharSc a = QLatin1Char (CQLatin1CharSc a) #

type TQLatin1CharSc a = TQLatin1Char (CQLatin1CharSc a) #

data CQLatin1CharSc a #

qCastList_QLatin1Char :: QqCastList_QLatin1Char a r => a -> r #

type QGenericReturnArgument a = Object (CQGenericReturnArgument a) #

type TQGenericReturnArgument a = CQGenericReturnArgument a #

data CQGenericReturnArgument a #

qCast_QGenericReturnArgument :: Object a -> IO (QGenericReturnArgument ()) #

type QGenericReturnArgumentSc a = QGenericReturnArgument (CQGenericReturnArgumentSc a) #

type TQGenericReturnArgumentSc a = TQGenericReturnArgument (CQGenericReturnArgumentSc a) #

data CQGenericReturnArgumentSc a #

qCastList_QGenericReturnArgument :: QqCastList_QGenericReturnArgument a r => a -> r #

type QTextCodec_ConverterState a = Object (CQTextCodec_ConverterState a) #

type TQTextCodec_ConverterState a = CQTextCodec_ConverterState a #

data CQTextCodec_ConverterState a #

qCast_QTextCodec_ConverterState :: Object a -> IO (QTextCodec_ConverterState ()) #

type QTextCodec_ConverterStateSc a = QTextCodec_ConverterState (CQTextCodec_ConverterStateSc a) #

type TQTextCodec_ConverterStateSc a = TQTextCodec_ConverterState (CQTextCodec_ConverterStateSc a) #

data CQTextCodec_ConverterStateSc a #

qCastList_QTextCodec_ConverterState :: QqCastList_QTextCodec_ConverterState a r => a -> r #

withQTextCodec_ConverterStateResult :: IO (Ptr (TQTextCodec_ConverterState a)) -> IO (QTextCodec_ConverterState a) #

type QTimeZone a = Object (CQTimeZone a) #

type TQTimeZone a = CQTimeZone a #

data CQTimeZone a #

qCast_QTimeZone :: Object a -> IO (QTimeZone ()) #

type QTimeZoneSc a = QTimeZone (CQTimeZoneSc a) #

type TQTimeZoneSc a = TQTimeZone (CQTimeZoneSc a) #

data CQTimeZoneSc a #

qCastList_QTimeZone :: QqCastList_QTimeZone a r => a -> r #

withQTimeZoneResult :: IO (Ptr (TQTimeZone a)) -> IO (QTimeZone a) #

type QOperatingSystemVersion a = Object (CQOperatingSystemVersion a) #

type TQOperatingSystemVersion a = CQOperatingSystemVersion a #

data CQOperatingSystemVersion a #

qCast_QOperatingSystemVersion :: Object a -> IO (QOperatingSystemVersion ()) #

type QOperatingSystemVersionSc a = QOperatingSystemVersion (CQOperatingSystemVersionSc a) #

type TQOperatingSystemVersionSc a = TQOperatingSystemVersion (CQOperatingSystemVersionSc a) #

data CQOperatingSystemVersionSc a #

qCastList_QOperatingSystemVersion :: QqCastList_QOperatingSystemVersion a r => a -> r #

withQOperatingSystemVersionResult :: IO (Ptr (TQOperatingSystemVersion a)) -> IO (QOperatingSystemVersion a) #

type QJsonArray_const_iterator a = Object (CQJsonArray_const_iterator a) #

type TQJsonArray_const_iterator a = CQJsonArray_const_iterator a #

data CQJsonArray_const_iterator a #

qCast_QJsonArray_const_iterator :: Object a -> IO (QJsonArray_const_iterator ()) #

type QJsonArray_const_iteratorSc a = QJsonArray_const_iterator (CQJsonArray_const_iteratorSc a) #

type TQJsonArray_const_iteratorSc a = TQJsonArray_const_iterator (CQJsonArray_const_iteratorSc a) #

data CQJsonArray_const_iteratorSc a #

qCastList_QJsonArray_const_iterator :: QqCastList_QJsonArray_const_iterator a r => a -> r #

withQJsonArray_const_iteratorResult :: IO (Ptr (TQJsonArray_const_iterator a)) -> IO (QJsonArray_const_iterator a) #