Documentation

type QTextFormat a = Object (CQTextFormat a) #

type TQTextFormat a = CQTextFormat a #

data CQTextFormat a #

qCast_QTextFormat :: Object a -> IO (QTextFormat ()) #

type QTextFormatSc a = QTextFormat (CQTextFormatSc a) #

type TQTextFormatSc a = TQTextFormat (CQTextFormatSc a) #

data CQTextFormatSc a #

qCastList_QTextFormat :: QqCastList_QTextFormat a r => a -> r #

withQTextFormatResult :: IO (Ptr (TQTextFormat a)) -> IO (QTextFormat a) #

withQVectorQTextFormatResult :: IO (Ptr (TQVectorQTextFormat ())) -> IO [QTextFormat ()] #

qTextFormatVectorFromPtrList :: [Ptr (TQTextFormat a)] -> IO [QTextFormat a] #

type QVectorQTextFormat a = Object (CQVectorQTextFormat a) #

type TQVectorQTextFormat a = CQVectorQTextFormat a #

data CQVectorQTextFormat a #

type QPaintDevice a = Object (CQPaintDevice a) #

type TQPaintDevice a = CQPaintDevice a #

data CQPaintDevice a #

qCast_QPaintDevice :: Object a -> IO (QPaintDevice ()) #

type QPaintDeviceSc a = QPaintDevice (CQPaintDeviceSc a) #

type TQPaintDeviceSc a = TQPaintDevice (CQPaintDeviceSc a) #

data CQPaintDeviceSc a #

qCastList_QPaintDevice :: QqCastList_QPaintDevice a r => a -> r #

withQPaintDeviceResult :: IO (Ptr (TQPaintDevice a)) -> IO (QPaintDevice a) #

type QInputEvent a = QEvent (CQInputEvent a) #

type TQInputEvent a = TQEvent (CQInputEvent a) #

data CQInputEvent a #

qCast_QInputEvent :: Object a -> IO (QInputEvent ()) #

type QInputEventSc a = QInputEvent (CQInputEventSc a) #

type TQInputEventSc a = TQInputEvent (CQInputEventSc a) #

data CQInputEventSc a #

qCastList_QInputEvent :: QqCastList_QInputEvent a r => a -> r #

withQInputEventResult :: IO (Ptr (TQInputEvent a)) -> IO (QInputEvent a) #

type QGradient a = Object (CQGradient a) #

type TQGradient a = CQGradient a #

data CQGradient a #

qCast_QGradient :: Object a -> IO (QGradient ()) #

type QGradientSc a = QGradient (CQGradientSc a) #

type TQGradientSc a = TQGradient (CQGradientSc a) #

data CQGradientSc a #

qCastList_QGradient :: QqCastList_QGradient a r => a -> r #

withQGradientResult :: IO (Ptr (TQGradient a)) -> IO (QGradient a) #

type QTextObject a = QObject (CQTextObject a) #

type TQTextObject a = TQObject (CQTextObject a) #

data CQTextObject a #

qCast_QTextObject :: Object a -> IO (QTextObject ()) #

type QTextObjectSc a = QTextObject (CQTextObjectSc a) #

type TQTextObjectSc a = TQTextObject (CQTextObjectSc a) #

data CQTextObjectSc a #

qCastList_QTextObject :: QqCastList_QTextObject a r => a -> r #

withQTextObjectResult :: IO (Ptr (TQTextObject a)) -> IO (QTextObject a) #

qTextObjectFromPtr :: Ptr (TQTextObject a) -> IO (QTextObject a) #

qTextObjectAddFinalizer :: QTextObject a -> IO () #

type QValidator a = QObject (CQValidator a) #

type TQValidator a = TQObject (CQValidator a) #

data CQValidator a #

qCast_QValidator :: Object a -> IO (QValidator ()) #

type QValidatorSc a = QValidator (CQValidatorSc a) #

type TQValidatorSc a = TQValidator (CQValidatorSc a) #

data CQValidatorSc a #

qCastList_QValidator :: QqCastList_QValidator a r => a -> r #

withQValidatorResult :: IO (Ptr (TQValidator a)) -> IO (QValidator a) #

qValidatorFromPtr :: Ptr (TQValidator a) -> IO (QValidator a) #

qValidatorAddFinalizer :: QValidator a -> IO () #

type QDropEvent a = QEvent (CQDropEvent a) #

type TQDropEvent a = TQEvent (CQDropEvent a) #

data CQDropEvent a #

qCast_QDropEvent :: Object a -> IO (QDropEvent ()) #

type QDropEventSc a = QDropEvent (CQDropEventSc a) #

type TQDropEventSc a = TQDropEvent (CQDropEventSc a) #

data CQDropEventSc a #

qCastList_QDropEvent :: QqCastList_QDropEvent a r => a -> r #

withQDropEventResult :: IO (Ptr (TQDropEvent a)) -> IO (QDropEvent a) #

type QTextCharFormat a = QTextFormat (CQTextCharFormat a) #

type TQTextCharFormat a = TQTextFormat (CQTextCharFormat a) #

data CQTextCharFormat a #

qCast_QTextCharFormat :: Object a -> IO (QTextCharFormat ()) #

type QTextCharFormatSc a = QTextCharFormat (CQTextCharFormatSc a) #

type TQTextCharFormatSc a = TQTextCharFormat (CQTextCharFormatSc a) #

data CQTextCharFormatSc a #

qCastList_QTextCharFormat :: QqCastList_QTextCharFormat a r => a -> r #

withQTextCharFormatResult :: IO (Ptr (TQTextCharFormat a)) -> IO (QTextCharFormat a) #

type QOpenGLFunctions a = Object (CQOpenGLFunctions a) #

type TQOpenGLFunctions a = CQOpenGLFunctions a #

data CQOpenGLFunctions a #

qCast_QOpenGLFunctions :: Object a -> IO (QOpenGLFunctions ()) #

type QOpenGLFunctionsSc a = QOpenGLFunctions (CQOpenGLFunctionsSc a) #

type TQOpenGLFunctionsSc a = TQOpenGLFunctions (CQOpenGLFunctionsSc a) #

data CQOpenGLFunctionsSc a #

qCastList_QOpenGLFunctions :: QqCastList_QOpenGLFunctions a r => a -> r #

withQOpenGLFunctionsResult :: IO (Ptr (TQOpenGLFunctions a)) -> IO (QOpenGLFunctions a) #

type QSurface a = Object (CQSurface a) #

type TQSurface a = CQSurface a #

data CQSurface a #

qCast_QSurface :: Object a -> IO (QSurface ()) #

type QSurfaceSc a = QSurface (CQSurfaceSc a) #

type TQSurfaceSc a = TQSurface (CQSurfaceSc a) #

data CQSurfaceSc a #

qCastList_QSurface :: QqCastList_QSurface a r => a -> r #

withQSurfaceResult :: IO (Ptr (TQSurface a)) -> IO (QSurface a) #

type QDragMoveEvent a = QDropEvent (CQDragMoveEvent a) #

type TQDragMoveEvent a = TQDropEvent (CQDragMoveEvent a) #

data CQDragMoveEvent a #

qCast_QDragMoveEvent :: Object a -> IO (QDragMoveEvent ()) #

type QDragMoveEventSc a = QDragMoveEvent (CQDragMoveEventSc a) #

type TQDragMoveEventSc a = TQDragMoveEvent (CQDragMoveEventSc a) #

data CQDragMoveEventSc a #

qCastList_QDragMoveEvent :: QqCastList_QDragMoveEvent a r => a -> r #

withQDragMoveEventResult :: IO (Ptr (TQDragMoveEvent a)) -> IO (QDragMoveEvent a) #

type QPagedPaintDevice a = QPaintDevice (CQPagedPaintDevice a) #

type TQPagedPaintDevice a = TQPaintDevice (CQPagedPaintDevice a) #

data CQPagedPaintDevice a #

qCast_QPagedPaintDevice :: Object a -> IO (QPagedPaintDevice ()) #

type QPagedPaintDeviceSc a = QPagedPaintDevice (CQPagedPaintDeviceSc a) #

type TQPagedPaintDeviceSc a = TQPagedPaintDevice (CQPagedPaintDeviceSc a) #

data CQPagedPaintDeviceSc a #

qCastList_QPagedPaintDevice :: QqCastList_QPagedPaintDevice a r => a -> r #

withQPagedPaintDeviceResult :: IO (Ptr (TQPagedPaintDevice a)) -> IO (QPagedPaintDevice a) #

type QPixmap a = QPaintDevice (CQPixmap a) #

type TQPixmap a = TQPaintDevice (CQPixmap a) #

data CQPixmap a #

qCast_QPixmap :: Object a -> IO (QPixmap ()) #

type QPixmapSc a = QPixmap (CQPixmapSc a) #

type TQPixmapSc a = TQPixmap (CQPixmapSc a) #

data CQPixmapSc a #

qCastList_QPixmap :: QqCastList_QPixmap a r => a -> r #

withQPixmapResult :: IO (Ptr (TQPixmap a)) -> IO (QPixmap a) #

type QTextFrameFormat a = QTextFormat (CQTextFrameFormat a) #

type TQTextFrameFormat a = TQTextFormat (CQTextFrameFormat a) #

data CQTextFrameFormat a #

qCast_QTextFrameFormat :: Object a -> IO (QTextFrameFormat ()) #

type QTextFrameFormatSc a = QTextFrameFormat (CQTextFrameFormatSc a) #

type TQTextFrameFormatSc a = TQTextFrameFormat (CQTextFrameFormatSc a) #

data CQTextFrameFormatSc a #

qCastList_QTextFrameFormat :: QqCastList_QTextFrameFormat a r => a -> r #

withQTextFrameFormatResult :: IO (Ptr (TQTextFrameFormat a)) -> IO (QTextFrameFormat a) #

type QTextFrame a = QTextObject (CQTextFrame a) #

type TQTextFrame a = TQTextObject (CQTextFrame a) #

data CQTextFrame a #

qCast_QTextFrame :: Object a -> IO (QTextFrame ()) #

type QTextFrameSc a = QTextFrame (CQTextFrameSc a) #

type TQTextFrameSc a = TQTextFrame (CQTextFrameSc a) #

data CQTextFrameSc a #

qCastList_QTextFrame :: QqCastList_QTextFrame a r => a -> r #

withQTextFrameResult :: IO (Ptr (TQTextFrame a)) -> IO (QTextFrame a) #

qTextFrameFromPtr :: Ptr (TQTextFrame a) -> IO (QTextFrame a) #

qTextFrameAddFinalizer :: QTextFrame a -> IO () #

withQListQTextFrameResult :: IO (Ptr (TQListQTextFrame ())) -> IO [QTextFrame ()] #

qTextFrameListFromPtrList :: [Ptr (TQTextFrame a)] -> IO [QTextFrame a] #

type QListQTextFrame a = Object (CQListQTextFrame a) #

type TQListQTextFrame a = CQListQTextFrame a #

data CQListQTextFrame a #

type QImageWriter a = Object (CQImageWriter a) #

type TQImageWriter a = CQImageWriter a #

data CQImageWriter a #

qCast_QImageWriter :: Object a -> IO (QImageWriter ()) #

type QImageWriterSc a = QImageWriter (CQImageWriterSc a) #

type TQImageWriterSc a = TQImageWriter (CQImageWriterSc a) #

data CQImageWriterSc a #

qCastList_QImageWriter :: QqCastList_QImageWriter a r => a -> r #

withQImageWriterResult :: IO (Ptr (TQImageWriter a)) -> IO (QImageWriter a) #

type QTextLine a = Object (CQTextLine a) #

type TQTextLine a = CQTextLine a #

data CQTextLine a #

qCast_QTextLine :: Object a -> IO (QTextLine ()) #

type QTextLineSc a = QTextLine (CQTextLineSc a) #

type TQTextLineSc a = TQTextLine (CQTextLineSc a) #

data CQTextLineSc a #

qCastList_QTextLine :: QqCastList_QTextLine a r => a -> r #

withQTextLineResult :: IO (Ptr (TQTextLine a)) -> IO (QTextLine a) #

type QColor a = Object (CQColor a) #

type TQColor a = CQColor a #

data CQColor a #

qCast_QColor :: Object a -> IO (QColor ()) #

type QColorSc a = QColor (CQColorSc a) #

type TQColorSc a = TQColor (CQColorSc a) #

data CQColorSc a #

qCastList_QColor :: QqCastList_QColor a r => a -> r #

withQColorResult :: IO (Ptr (TQColor a)) -> IO (QColor a) #

withQListQColorResult :: IO (Ptr (TQListQColor ())) -> IO [QColor ()] #

qColorListFromPtrList :: [Ptr (TQColor a)] -> IO [QColor a] #

type QListQColor a = Object (CQListQColor a) #

type TQListQColor a = CQListQColor a #

data CQListQColor a #

withQVectorQColorResult :: IO (Ptr (TQVectorQColor ())) -> IO [QColor ()] #

qColorVectorFromPtrList :: [Ptr (TQColor a)] -> IO [QColor a] #

type QVectorQColor a = Object (CQVectorQColor a) #

type TQVectorQColor a = CQVectorQColor a #

data CQVectorQColor a #

type QTextBlock_iterator a = Object (CQTextBlock_iterator a) #

type TQTextBlock_iterator a = CQTextBlock_iterator a #

data CQTextBlock_iterator a #

qCast_QTextBlock_iterator :: Object a -> IO (QTextBlock_iterator ()) #

type QTextBlock_iteratorSc a = QTextBlock_iterator (CQTextBlock_iteratorSc a) #

type TQTextBlock_iteratorSc a = TQTextBlock_iterator (CQTextBlock_iteratorSc a) #

data CQTextBlock_iteratorSc a #

qCastList_QTextBlock_iterator :: QqCastList_QTextBlock_iterator a r => a -> r #

withQTextBlock_iteratorResult :: IO (Ptr (TQTextBlock_iterator a)) -> IO (QTextBlock_iterator a) #

type QMatrix4x4 a = Object (CQMatrix4x4 a) #

type TQMatrix4x4 a = CQMatrix4x4 a #

data CQMatrix4x4 a #

qCast_QMatrix4x4 :: Object a -> IO (QMatrix4x4 ()) #

type QMatrix4x4Sc a = QMatrix4x4 (CQMatrix4x4Sc a) #

type TQMatrix4x4Sc a = TQMatrix4x4 (CQMatrix4x4Sc a) #

data CQMatrix4x4Sc a #

qCastList_QMatrix4x4 :: QqCastList_QMatrix4x4 a r => a -> r #

withQMatrix4x4Result :: IO (Ptr (TQMatrix4x4 a)) -> IO (QMatrix4x4 a) #

type QPixelFormat a = Object (CQPixelFormat a) #

type TQPixelFormat a = CQPixelFormat a #

data CQPixelFormat a #

qCast_QPixelFormat :: Object a -> IO (QPixelFormat ()) #

type QPixelFormatSc a = QPixelFormat (CQPixelFormatSc a) #

type TQPixelFormatSc a = TQPixelFormat (CQPixelFormatSc a) #

data CQPixelFormatSc a #

qCastList_QPixelFormat :: QqCastList_QPixelFormat a r => a -> r #

withQPixelFormatResult :: IO (Ptr (TQPixelFormat a)) -> IO (QPixelFormat a) #

type QKeySequence a = Object (CQKeySequence a) #

type TQKeySequence a = CQKeySequence a #

data CQKeySequence a #

qCast_QKeySequence :: Object a -> IO (QKeySequence ()) #

type QKeySequenceSc a = QKeySequence (CQKeySequenceSc a) #

type TQKeySequenceSc a = TQKeySequence (CQKeySequenceSc a) #

data CQKeySequenceSc a #

qCastList_QKeySequence :: QqCastList_QKeySequence a r => a -> r #

withQKeySequenceResult :: IO (Ptr (TQKeySequence a)) -> IO (QKeySequence a) #

withQListQKeySequenceResult :: IO (Ptr (TQListQKeySequence ())) -> IO [QKeySequence ()] #

qKeySequenceListFromPtrList :: [Ptr (TQKeySequence a)] -> IO [QKeySequence a] #

type QListQKeySequence a = Object (CQListQKeySequence a) #

type TQListQKeySequence a = CQListQKeySequence a #

data CQListQKeySequence a #

type QOpenGLPixelTransferOptions a = Object (CQOpenGLPixelTransferOptions a) #

type TQOpenGLPixelTransferOptions a = CQOpenGLPixelTransferOptions a #

data CQOpenGLPixelTransferOptions a #

qCast_QOpenGLPixelTransferOptions :: Object a -> IO (QOpenGLPixelTransferOptions ()) #

type QOpenGLPixelTransferOptionsSc a = QOpenGLPixelTransferOptions (CQOpenGLPixelTransferOptionsSc a) #

type TQOpenGLPixelTransferOptionsSc a = TQOpenGLPixelTransferOptions (CQOpenGLPixelTransferOptionsSc a) #

data CQOpenGLPixelTransferOptionsSc a #

qCastList_QOpenGLPixelTransferOptions :: QqCastList_QOpenGLPixelTransferOptions a r => a -> r #

withQOpenGLPixelTransferOptionsResult :: IO (Ptr (TQOpenGLPixelTransferOptions a)) -> IO (QOpenGLPixelTransferOptions a) #

type QPlatformPixmap a = Object (CQPlatformPixmap a) #

type TQPlatformPixmap a = CQPlatformPixmap a #

data CQPlatformPixmap a #

qCast_QPlatformPixmap :: Object a -> IO (QPlatformPixmap ()) #

type QPlatformPixmapSc a = QPlatformPixmap (CQPlatformPixmapSc a) #

type TQPlatformPixmapSc a = TQPlatformPixmap (CQPlatformPixmapSc a) #

data CQPlatformPixmapSc a #

qCastList_QPlatformPixmap :: QqCastList_QPlatformPixmap a r => a -> r #

withQPlatformPixmapResult :: IO (Ptr (TQPlatformPixmap a)) -> IO (QPlatformPixmap a) #

type QFont a = Object (CQFont a) #

type TQFont a = CQFont a #

data CQFont a #

qCast_QFont :: Object a -> IO (QFont ()) #

type QFontSc a = QFont (CQFontSc a) #

type TQFontSc a = TQFont (CQFontSc a) #

data CQFontSc a #

qCastList_QFont :: QqCastList_QFont a r => a -> r #

withQFontResult :: IO (Ptr (TQFont a)) -> IO (QFont a) #

type QFontMetrics a = Object (CQFontMetrics a) #

type TQFontMetrics a = CQFontMetrics a #

data CQFontMetrics a #

qCast_QFontMetrics :: Object a -> IO (QFontMetrics ()) #

type QFontMetricsSc a = QFontMetrics (CQFontMetricsSc a) #

type TQFontMetricsSc a = TQFontMetrics (CQFontMetricsSc a) #

data CQFontMetricsSc a #

qCastList_QFontMetrics :: QqCastList_QFontMetrics a r => a -> r #

withQFontMetricsResult :: IO (Ptr (TQFontMetrics a)) -> IO (QFontMetrics a) #

type QVector4D a = Object (CQVector4D a) #

type TQVector4D a = CQVector4D a #

data CQVector4D a #

qCast_QVector4D :: Object a -> IO (QVector4D ()) #

type QVector4DSc a = QVector4D (CQVector4DSc a) #

type TQVector4DSc a = TQVector4D (CQVector4DSc a) #

data CQVector4DSc a #

qCastList_QVector4D :: QqCastList_QVector4D a r => a -> r #

withQVector4DResult :: IO (Ptr (TQVector4D a)) -> IO (QVector4D a) #

type QImageIOHandler a = Object (CQImageIOHandler a) #

type TQImageIOHandler a = CQImageIOHandler a #

data CQImageIOHandler a #

qCast_QImageIOHandler :: Object a -> IO (QImageIOHandler ()) #

type QImageIOHandlerSc a = QImageIOHandler (CQImageIOHandlerSc a) #

type TQImageIOHandlerSc a = TQImageIOHandler (CQImageIOHandlerSc a) #

data CQImageIOHandlerSc a #

qCastList_QImageIOHandler :: QqCastList_QImageIOHandler a r => a -> r #

withQImageIOHandlerResult :: IO (Ptr (TQImageIOHandler a)) -> IO (QImageIOHandler a) #

type QTextInlineObject a = Object (CQTextInlineObject a) #

type TQTextInlineObject a = CQTextInlineObject a #

data CQTextInlineObject a #

qCast_QTextInlineObject :: Object a -> IO (QTextInlineObject ()) #

type QTextInlineObjectSc a = QTextInlineObject (CQTextInlineObjectSc a) #

type TQTextInlineObjectSc a = TQTextInlineObject (CQTextInlineObjectSc a) #

data CQTextInlineObjectSc a #

qCastList_QTextInlineObject :: QqCastList_QTextInlineObject a r => a -> r #

withQTextInlineObjectResult :: IO (Ptr (TQTextInlineObject a)) -> IO (QTextInlineObject a) #

type QCursor a = Object (CQCursor a) #

type TQCursor a = CQCursor a #

data CQCursor a #

qCast_QCursor :: Object a -> IO (QCursor ()) #

type QCursorSc a = QCursor (CQCursorSc a) #

type TQCursorSc a = TQCursor (CQCursorSc a) #

data CQCursorSc a #

qCastList_QCursor :: QqCastList_QCursor a r => a -> r #

withQCursorResult :: IO (Ptr (TQCursor a)) -> IO (QCursor a) #

type QPainterPath_Element a = Object (CQPainterPath_Element a) #

type TQPainterPath_Element a = CQPainterPath_Element a #

data CQPainterPath_Element a #

qCast_QPainterPath_Element :: Object a -> IO (QPainterPath_Element ()) #

type QPainterPath_ElementSc a = QPainterPath_Element (CQPainterPath_ElementSc a) #

type TQPainterPath_ElementSc a = TQPainterPath_Element (CQPainterPath_ElementSc a) #

data CQPainterPath_ElementSc a #

qCastList_QPainterPath_Element :: QqCastList_QPainterPath_Element a r => a -> r #

withQPainterPath_ElementResult :: IO (Ptr (TQPainterPath_Element a)) -> IO (QPainterPath_Element a) #

type QPenPrivate a = Object (CQPenPrivate a) #

type TQPenPrivate a = CQPenPrivate a #

data CQPenPrivate a #

qCast_QPenPrivate :: Object a -> IO (QPenPrivate ()) #

type QPenPrivateSc a = QPenPrivate (CQPenPrivateSc a) #

type TQPenPrivateSc a = TQPenPrivate (CQPenPrivateSc a) #

data CQPenPrivateSc a #

qCastList_QPenPrivate :: QqCastList_QPenPrivate a r => a -> r #

type QBrush a = Object (CQBrush a) #

type TQBrush a = CQBrush a #

data CQBrush a #

qCast_QBrush :: Object a -> IO (QBrush ()) #

type QBrushSc a = QBrush (CQBrushSc a) #

type TQBrushSc a = TQBrush (CQBrushSc a) #

data CQBrushSc a #

qCastList_QBrush :: QqCastList_QBrush a r => a -> r #

withQBrushResult :: IO (Ptr (TQBrush a)) -> IO (QBrush a) #

type QPen a = Object (CQPen a) #

type TQPen a = CQPen a #

data CQPen a #

qCast_QPen :: Object a -> IO (QPen ()) #

type QPenSc a = QPen (CQPenSc a) #

type TQPenSc a = TQPen (CQPenSc a) #

data CQPenSc a #

qCastList_QPen :: QqCastList_QPen a r => a -> r #

withQPenResult :: IO (Ptr (TQPen a)) -> IO (QPen a) #

type QPixmapCache_Key a = Object (CQPixmapCache_Key a) #

type TQPixmapCache_Key a = CQPixmapCache_Key a #

data CQPixmapCache_Key a #

qCast_QPixmapCache_Key :: Object a -> IO (QPixmapCache_Key ()) #

type QPixmapCache_KeySc a = QPixmapCache_Key (CQPixmapCache_KeySc a) #

type TQPixmapCache_KeySc a = TQPixmapCache_Key (CQPixmapCache_KeySc a) #

data CQPixmapCache_KeySc a #

qCastList_QPixmapCache_Key :: QqCastList_QPixmapCache_Key a r => a -> r #

withQPixmapCache_KeyResult :: IO (Ptr (TQPixmapCache_Key a)) -> IO (QPixmapCache_Key a) #

type QAbstractOpenGLFunctions a = Object (CQAbstractOpenGLFunctions a) #

type TQAbstractOpenGLFunctions a = CQAbstractOpenGLFunctions a #

data CQAbstractOpenGLFunctions a #

qCast_QAbstractOpenGLFunctions :: Object a -> IO (QAbstractOpenGLFunctions ()) #

type QAbstractOpenGLFunctionsSc a = QAbstractOpenGLFunctions (CQAbstractOpenGLFunctionsSc a) #

type TQAbstractOpenGLFunctionsSc a = TQAbstractOpenGLFunctions (CQAbstractOpenGLFunctionsSc a) #

data CQAbstractOpenGLFunctionsSc a #

qCastList_QAbstractOpenGLFunctions :: QqCastList_QAbstractOpenGLFunctions a r => a -> r #

type QTransform a = Object (CQTransform a) #

type TQTransform a = CQTransform a #

data CQTransform a #

qCast_QTransform :: Object a -> IO (QTransform ()) #

type QTransformSc a = QTransform (CQTransformSc a) #

type TQTransformSc a = TQTransform (CQTransformSc a) #

data CQTransformSc a #

qCastList_QTransform :: QqCastList_QTransform a r => a -> r #

withQTransformResult :: IO (Ptr (TQTransform a)) -> IO (QTransform a) #

type QStandardItem a = Object (CQStandardItem a) #

type TQStandardItem a = CQStandardItem a #

data CQStandardItem a #

qCast_QStandardItem :: Object a -> IO (QStandardItem ()) #

type QStandardItemSc a = QStandardItem (CQStandardItemSc a) #

type TQStandardItemSc a = TQStandardItem (CQStandardItemSc a) #

data CQStandardItemSc a #

qCastList_QStandardItem :: QqCastList_QStandardItem a r => a -> r #

withQStandardItemResult :: IO (Ptr (TQStandardItem a)) -> IO (QStandardItem a) #

withQListQStandardItemResult :: IO (Ptr (TQListQStandardItem ())) -> IO [QStandardItem ()] #

qStandardItemListFromPtrList :: [Ptr (TQStandardItem a)] -> IO [QStandardItem a] #

type QListQStandardItem a = Object (CQListQStandardItem a) #

type TQListQStandardItem a = CQListQStandardItem a #

data CQListQStandardItem a #

type QPlatformScreen a = Object (CQPlatformScreen a) #

type TQPlatformScreen a = CQPlatformScreen a #

data CQPlatformScreen a #

qCast_QPlatformScreen :: Object a -> IO (QPlatformScreen ()) #

type QPlatformScreenSc a = QPlatformScreen (CQPlatformScreenSc a) #

type TQPlatformScreenSc a = TQPlatformScreen (CQPlatformScreenSc a) #

data CQPlatformScreenSc a #

qCastList_QPlatformScreen :: QqCastList_QPlatformScreen a r => a -> r #

withQPlatformScreenResult :: IO (Ptr (TQPlatformScreen a)) -> IO (QPlatformScreen a) #

type QImageReader a = Object (CQImageReader a) #

type TQImageReader a = CQImageReader a #

data CQImageReader a #

qCast_QImageReader :: Object a -> IO (QImageReader ()) #

type QImageReaderSc a = QImageReader (CQImageReaderSc a) #

type TQImageReaderSc a = TQImageReader (CQImageReaderSc a) #

data CQImageReaderSc a #

qCastList_QImageReader :: QqCastList_QImageReader a r => a -> r #

withQImageReaderResult :: IO (Ptr (TQImageReader a)) -> IO (QImageReader a) #

type QVector2D a = Object (CQVector2D a) #

type TQVector2D a = CQVector2D a #

data CQVector2D a #

qCast_QVector2D :: Object a -> IO (QVector2D ()) #

type QVector2DSc a = QVector2D (CQVector2DSc a) #

type TQVector2DSc a = TQVector2D (CQVector2DSc a) #

data CQVector2DSc a #

qCastList_QVector2D :: QqCastList_QVector2D a r => a -> r #

withQVector2DResult :: IO (Ptr (TQVector2D a)) -> IO (QVector2D a) #

type QInputMethodEvent_Attribute a = Object (CQInputMethodEvent_Attribute a) #

type TQInputMethodEvent_Attribute a = CQInputMethodEvent_Attribute a #

data CQInputMethodEvent_Attribute a #

qCast_QInputMethodEvent_Attribute :: Object a -> IO (QInputMethodEvent_Attribute ()) #

type QInputMethodEvent_AttributeSc a = QInputMethodEvent_Attribute (CQInputMethodEvent_AttributeSc a) #

type TQInputMethodEvent_AttributeSc a = TQInputMethodEvent_Attribute (CQInputMethodEvent_AttributeSc a) #

data CQInputMethodEvent_AttributeSc a #

qCastList_QInputMethodEvent_Attribute :: QqCastList_QInputMethodEvent_Attribute a r => a -> r #

withQInputMethodEvent_AttributeResult :: IO (Ptr (TQInputMethodEvent_Attribute a)) -> IO (QInputMethodEvent_Attribute a) #

withQListQInputMethodEvent_AttributeResult :: IO (Ptr (TQListQInputMethodEvent_Attribute ())) -> IO [QInputMethodEvent_Attribute ()] #

qInputMethodEvent_AttributeListFromPtrList :: [Ptr (TQInputMethodEvent_Attribute a)] -> IO [QInputMethodEvent_Attribute a] #

type QListQInputMethodEvent_Attribute a = Object (CQListQInputMethodEvent_Attribute a) #

type TQListQInputMethodEvent_Attribute a = CQListQInputMethodEvent_Attribute a #

data CQListQInputMethodEvent_Attribute a #

type QIconPrivate a = Object (CQIconPrivate a) #

type TQIconPrivate a = CQIconPrivate a #

data CQIconPrivate a #

qCast_QIconPrivate :: Object a -> IO (QIconPrivate ()) #

type QIconPrivateSc a = QIconPrivate (CQIconPrivateSc a) #

type TQIconPrivateSc a = TQIconPrivate (CQIconPrivateSc a) #

data CQIconPrivateSc a #

qCastList_QIconPrivate :: QqCastList_QIconPrivate a r => a -> r #

type QOpenGLVersionProfile a = Object (CQOpenGLVersionProfile a) #

type TQOpenGLVersionProfile a = CQOpenGLVersionProfile a #

data CQOpenGLVersionProfile a #

qCast_QOpenGLVersionProfile :: Object a -> IO (QOpenGLVersionProfile ()) #

type QOpenGLVersionProfileSc a = QOpenGLVersionProfile (CQOpenGLVersionProfileSc a) #

type TQOpenGLVersionProfileSc a = TQOpenGLVersionProfile (CQOpenGLVersionProfileSc a) #

data CQOpenGLVersionProfileSc a #

qCastList_QOpenGLVersionProfile :: QqCastList_QOpenGLVersionProfile a r => a -> r #

withQOpenGLVersionProfileResult :: IO (Ptr (TQOpenGLVersionProfile a)) -> IO (QOpenGLVersionProfile a) #

type QTouchDevice a = Object (CQTouchDevice a) #

type TQTouchDevice a = CQTouchDevice a #

data CQTouchDevice a #

qCast_QTouchDevice :: Object a -> IO (QTouchDevice ()) #

type QTouchDeviceSc a = QTouchDevice (CQTouchDeviceSc a) #

type TQTouchDeviceSc a = TQTouchDevice (CQTouchDeviceSc a) #

data CQTouchDeviceSc a #

qCastList_QTouchDevice :: QqCastList_QTouchDevice a r => a -> r #

withQTouchDeviceResult :: IO (Ptr (TQTouchDevice a)) -> IO (QTouchDevice a) #

withQListQTouchDeviceResult :: IO (Ptr (TQListQTouchDevice ())) -> IO [QTouchDevice ()] #

qTouchDeviceListFromPtrList :: [Ptr (TQTouchDevice a)] -> IO [QTouchDevice a] #

type QListQTouchDevice a = Object (CQListQTouchDevice a) #

type TQListQTouchDevice a = CQListQTouchDevice a #

data CQListQTouchDevice a #

type QMatrix a = Object (CQMatrix a) #

type TQMatrix a = CQMatrix a #

data CQMatrix a #

qCast_QMatrix :: Object a -> IO (QMatrix ()) #

type QMatrixSc a = QMatrix (CQMatrixSc a) #

type TQMatrixSc a = TQMatrix (CQMatrixSc a) #

data CQMatrixSc a #

qCastList_QMatrix :: QqCastList_QMatrix a r => a -> r #

withQMatrixResult :: IO (Ptr (TQMatrix a)) -> IO (QMatrix a) #

type QBackingStore a = Object (CQBackingStore a) #

type TQBackingStore a = CQBackingStore a #

data CQBackingStore a #

qCast_QBackingStore :: Object a -> IO (QBackingStore ()) #

type QBackingStoreSc a = QBackingStore (CQBackingStoreSc a) #

type TQBackingStoreSc a = TQBackingStore (CQBackingStoreSc a) #

data CQBackingStoreSc a #

qCastList_QBackingStore :: QqCastList_QBackingStore a r => a -> r #

withQBackingStoreResult :: IO (Ptr (TQBackingStore a)) -> IO (QBackingStore a) #

type QBrushData a = Object (CQBrushData a) #

type TQBrushData a = CQBrushData a #

data CQBrushData a #

qCast_QBrushData :: Object a -> IO (QBrushData ()) #

type QBrushDataSc a = QBrushData (CQBrushDataSc a) #

type TQBrushDataSc a = TQBrushData (CQBrushDataSc a) #

data CQBrushDataSc a #

qCastList_QBrushData :: QqCastList_QBrushData a r => a -> r #

withQBrushDataResult :: IO (Ptr (TQBrushData a)) -> IO (QBrushData a) #

type QPolygonF a = Object (CQPolygonF a) #

type TQPolygonF a = CQPolygonF a #

data CQPolygonF a #

qCast_QPolygonF :: Object a -> IO (QPolygonF ()) #

type QPolygonFSc a = QPolygonF (CQPolygonFSc a) #

type TQPolygonFSc a = TQPolygonF (CQPolygonFSc a) #

data CQPolygonFSc a #

qCastList_QPolygonF :: QqCastList_QPolygonF a r => a -> r #

withQPolygonFResult :: IO (Ptr (TQPolygonF a)) -> IO (QPolygonF a) #

withQListQPolygonFResult :: IO (Ptr (TQListQPolygonF ())) -> IO [QPolygonF ()] #

qPolygonFListFromPtrList :: [Ptr (TQPolygonF a)] -> IO [QPolygonF a] #

type QListQPolygonF a = Object (CQListQPolygonF a) #

type TQListQPolygonF a = CQListQPolygonF a #

data CQListQPolygonF a #

type QBrushDataPointerDeleter a = Object (CQBrushDataPointerDeleter a) #

type TQBrushDataPointerDeleter a = CQBrushDataPointerDeleter a #

data CQBrushDataPointerDeleter a #

qCast_QBrushDataPointerDeleter :: Object a -> IO (QBrushDataPointerDeleter ()) #

type QBrushDataPointerDeleterSc a = QBrushDataPointerDeleter (CQBrushDataPointerDeleterSc a) #

type TQBrushDataPointerDeleterSc a = TQBrushDataPointerDeleter (CQBrushDataPointerDeleterSc a) #

data CQBrushDataPointerDeleterSc a #

qCastList_QBrushDataPointerDeleter :: QqCastList_QBrushDataPointerDeleter a r => a -> r #

withQBrushDataPointerDeleterResult :: IO (Ptr (TQBrushDataPointerDeleter a)) -> IO (QBrushDataPointerDeleter a) #

type QOpenGLFramebufferObject a = Object (CQOpenGLFramebufferObject a) #

type TQOpenGLFramebufferObject a = CQOpenGLFramebufferObject a #

data CQOpenGLFramebufferObject a #

qCast_QOpenGLFramebufferObject :: Object a -> IO (QOpenGLFramebufferObject ()) #

type QOpenGLFramebufferObjectSc a = QOpenGLFramebufferObject (CQOpenGLFramebufferObjectSc a) #

type TQOpenGLFramebufferObjectSc a = TQOpenGLFramebufferObject (CQOpenGLFramebufferObjectSc a) #

data CQOpenGLFramebufferObjectSc a #

qCastList_QOpenGLFramebufferObject :: QqCastList_QOpenGLFramebufferObject a r => a -> r #

withQOpenGLFramebufferObjectResult :: IO (Ptr (TQOpenGLFramebufferObject a)) -> IO (QOpenGLFramebufferObject a) #

type QTextEngine a = Object (CQTextEngine a) #

type TQTextEngine a = CQTextEngine a #

data CQTextEngine a #

qCast_QTextEngine :: Object a -> IO (QTextEngine ()) #

type QTextEngineSc a = QTextEngine (CQTextEngineSc a) #

type TQTextEngineSc a = TQTextEngine (CQTextEngineSc a) #

data CQTextEngineSc a #

qCastList_QTextEngine :: QqCastList_QTextEngine a r => a -> r #

withQTextEngineResult :: IO (Ptr (TQTextEngine a)) -> IO (QTextEngine a) #

type QOpenGLTexture a = Object (CQOpenGLTexture a) #

type TQOpenGLTexture a = CQOpenGLTexture a #

data CQOpenGLTexture a #

qCast_QOpenGLTexture :: Object a -> IO (QOpenGLTexture ()) #

type QOpenGLTextureSc a = QOpenGLTexture (CQOpenGLTextureSc a) #

type TQOpenGLTextureSc a = TQOpenGLTexture (CQOpenGLTextureSc a) #

data CQOpenGLTextureSc a #

qCastList_QOpenGLTexture :: QqCastList_QOpenGLTexture a r => a -> r #

withQOpenGLTextureResult :: IO (Ptr (TQOpenGLTexture a)) -> IO (QOpenGLTexture a) #

type QTextDocumentPrivate a = Object (CQTextDocumentPrivate a) #

type TQTextDocumentPrivate a = CQTextDocumentPrivate a #

data CQTextDocumentPrivate a #

qCast_QTextDocumentPrivate :: Object a -> IO (QTextDocumentPrivate ()) #

type QTextDocumentPrivateSc a = QTextDocumentPrivate (CQTextDocumentPrivateSc a) #

type TQTextDocumentPrivateSc a = TQTextDocumentPrivate (CQTextDocumentPrivateSc a) #

data CQTextDocumentPrivateSc a #

qCastList_QTextDocumentPrivate :: QqCastList_QTextDocumentPrivate a r => a -> r #

type QQuaternion a = Object (CQQuaternion a) #

type TQQuaternion a = CQQuaternion a #

data CQQuaternion a #

qCast_QQuaternion :: Object a -> IO (QQuaternion ()) #

type QQuaternionSc a = QQuaternion (CQQuaternionSc a) #

type TQQuaternionSc a = TQQuaternion (CQQuaternionSc a) #

data CQQuaternionSc a #

qCastList_QQuaternion :: QqCastList_QQuaternion a r => a -> r #

withQQuaternionResult :: IO (Ptr (TQQuaternion a)) -> IO (QQuaternion a) #

type QImageData a = Object (CQImageData a) #

type TQImageData a = CQImageData a #

data CQImageData a #

qCast_QImageData :: Object a -> IO (QImageData ()) #

type QImageDataSc a = QImageData (CQImageDataSc a) #

type TQImageDataSc a = TQImageData (CQImageDataSc a) #

data CQImageDataSc a #

qCastList_QImageData :: QqCastList_QImageData a r => a -> r #

withQImageDataResult :: IO (Ptr (TQImageData a)) -> IO (QImageData a) #

type QTextBlock a = Object (CQTextBlock a) #

type TQTextBlock a = CQTextBlock a #

data CQTextBlock a #

qCast_QTextBlock :: Object a -> IO (QTextBlock ()) #

type QTextBlockSc a = QTextBlock (CQTextBlockSc a) #

type TQTextBlockSc a = TQTextBlock (CQTextBlockSc a) #

data CQTextBlockSc a #

qCastList_QTextBlock :: QqCastList_QTextBlock a r => a -> r #

withQTextBlockResult :: IO (Ptr (TQTextBlock a)) -> IO (QTextBlock a) #

withQListQTextBlockResult :: IO (Ptr (TQListQTextBlock ())) -> IO [QTextBlock ()] #

qTextBlockListFromPtrList :: [Ptr (TQTextBlock a)] -> IO [QTextBlock a] #

type QListQTextBlock a = Object (CQListQTextBlock a) #

type TQListQTextBlock a = CQListQTextBlock a #

data CQListQTextBlock a #

type QFontMetricsF a = Object (CQFontMetricsF a) #

type TQFontMetricsF a = CQFontMetricsF a #

data CQFontMetricsF a #

qCast_QFontMetricsF :: Object a -> IO (QFontMetricsF ()) #

type QFontMetricsFSc a = QFontMetricsF (CQFontMetricsFSc a) #

type TQFontMetricsFSc a = TQFontMetricsF (CQFontMetricsFSc a) #

data CQFontMetricsFSc a #

qCastList_QFontMetricsF :: QqCastList_QFontMetricsF a r => a -> r #

withQFontMetricsFResult :: IO (Ptr (TQFontMetricsF a)) -> IO (QFontMetricsF a) #

type QTextFrame_iterator a = Object (CQTextFrame_iterator a) #

type TQTextFrame_iterator a = CQTextFrame_iterator a #

data CQTextFrame_iterator a #

qCast_QTextFrame_iterator :: Object a -> IO (QTextFrame_iterator ()) #

type QTextFrame_iteratorSc a = QTextFrame_iterator (CQTextFrame_iteratorSc a) #

type TQTextFrame_iteratorSc a = TQTextFrame_iterator (CQTextFrame_iteratorSc a) #

data CQTextFrame_iteratorSc a #

qCastList_QTextFrame_iterator :: QqCastList_QTextFrame_iterator a r => a -> r #

withQTextFrame_iteratorResult :: IO (Ptr (TQTextFrame_iterator a)) -> IO (QTextFrame_iterator a) #

type QRegion a = Object (CQRegion a) #

type TQRegion a = CQRegion a #

data CQRegion a #

qCast_QRegion :: Object a -> IO (QRegion ()) #

type QRegionSc a = QRegion (CQRegionSc a) #

type TQRegionSc a = TQRegion (CQRegionSc a) #

data CQRegionSc a #

qCastList_QRegion :: QqCastList_QRegion a r => a -> r #

withQRegionResult :: IO (Ptr (TQRegion a)) -> IO (QRegion a) #

type QPainterPath a = Object (CQPainterPath a) #

type TQPainterPath a = CQPainterPath a #

data CQPainterPath a #

qCast_QPainterPath :: Object a -> IO (QPainterPath ()) #

type QPainterPathSc a = QPainterPath (CQPainterPathSc a) #

type TQPainterPathSc a = TQPainterPath (CQPainterPathSc a) #

data CQPainterPathSc a #

qCastList_QPainterPath :: QqCastList_QPainterPath a r => a -> r #

withQPainterPathResult :: IO (Ptr (TQPainterPath a)) -> IO (QPainterPath a) #

type QTouchEvent_TouchPoint a = Object (CQTouchEvent_TouchPoint a) #

type TQTouchEvent_TouchPoint a = CQTouchEvent_TouchPoint a #

data CQTouchEvent_TouchPoint a #

qCast_QTouchEvent_TouchPoint :: Object a -> IO (QTouchEvent_TouchPoint ()) #

type QTouchEvent_TouchPointSc a = QTouchEvent_TouchPoint (CQTouchEvent_TouchPointSc a) #

type TQTouchEvent_TouchPointSc a = TQTouchEvent_TouchPoint (CQTouchEvent_TouchPointSc a) #

data CQTouchEvent_TouchPointSc a #

qCastList_QTouchEvent_TouchPoint :: QqCastList_QTouchEvent_TouchPoint a r => a -> r #

withQTouchEvent_TouchPointResult :: IO (Ptr (TQTouchEvent_TouchPoint a)) -> IO (QTouchEvent_TouchPoint a) #

withQListQTouchEvent_TouchPointResult :: IO (Ptr (TQListQTouchEvent_TouchPoint ())) -> IO [QTouchEvent_TouchPoint ()] #

qTouchEvent_TouchPointListFromPtrList :: [Ptr (TQTouchEvent_TouchPoint a)] -> IO [QTouchEvent_TouchPoint a] #

type QListQTouchEvent_TouchPoint a = Object (CQListQTouchEvent_TouchPoint a) #

type TQListQTouchEvent_TouchPoint a = CQListQTouchEvent_TouchPoint a #

data CQListQTouchEvent_TouchPoint a #

type QSurfacePrivate a = Object (CQSurfacePrivate a) #

type TQSurfacePrivate a = CQSurfacePrivate a #

data CQSurfacePrivate a #

qCast_QSurfacePrivate :: Object a -> IO (QSurfacePrivate ()) #

type QSurfacePrivateSc a = QSurfacePrivate (CQSurfacePrivateSc a) #

type TQSurfacePrivateSc a = TQSurfacePrivate (CQSurfacePrivateSc a) #

data CQSurfacePrivateSc a #

qCastList_QSurfacePrivate :: QqCastList_QSurfacePrivate a r => a -> r #

type QStaticText a = Object (CQStaticText a) #

type TQStaticText a = CQStaticText a #

data CQStaticText a #

qCast_QStaticText :: Object a -> IO (QStaticText ()) #

type QStaticTextSc a = QStaticText (CQStaticTextSc a) #

type TQStaticTextSc a = TQStaticText (CQStaticTextSc a) #

data CQStaticTextSc a #

qCastList_QStaticText :: QqCastList_QStaticText a r => a -> r #

withQStaticTextResult :: IO (Ptr (TQStaticText a)) -> IO (QStaticText a) #

type QPlatformOpenGLContext a = Object (CQPlatformOpenGLContext a) #

type TQPlatformOpenGLContext a = CQPlatformOpenGLContext a #

data CQPlatformOpenGLContext a #

qCast_QPlatformOpenGLContext :: Object a -> IO (QPlatformOpenGLContext ()) #

type QPlatformOpenGLContextSc a = QPlatformOpenGLContext (CQPlatformOpenGLContextSc a) #

type TQPlatformOpenGLContextSc a = TQPlatformOpenGLContext (CQPlatformOpenGLContextSc a) #

data CQPlatformOpenGLContextSc a #

qCastList_QPlatformOpenGLContext :: QqCastList_QPlatformOpenGLContext a r => a -> r #

withQPlatformOpenGLContextResult :: IO (Ptr (TQPlatformOpenGLContext a)) -> IO (QPlatformOpenGLContext a) #

type QPixmapCache a = Object (CQPixmapCache a) #

type TQPixmapCache a = CQPixmapCache a #

data CQPixmapCache a #

qCast_QPixmapCache :: Object a -> IO (QPixmapCache ()) #

type QPixmapCacheSc a = QPixmapCache (CQPixmapCacheSc a) #

type TQPixmapCacheSc a = TQPixmapCache (CQPixmapCacheSc a) #

data CQPixmapCacheSc a #

qCastList_QPixmapCache :: QqCastList_QPixmapCache a r => a -> r #

withQPixmapCacheResult :: IO (Ptr (TQPixmapCache a)) -> IO (QPixmapCache a) #

type QIcon a = Object (CQIcon a) #

type TQIcon a = CQIcon a #

data CQIcon a #

qCast_QIcon :: Object a -> IO (QIcon ()) #

type QIconSc a = QIcon (CQIconSc a) #

type TQIconSc a = TQIcon (CQIconSc a) #

data CQIconSc a #

qCastList_QIcon :: QqCastList_QIcon a r => a -> r #

withQIconResult :: IO (Ptr (TQIcon a)) -> IO (QIcon a) #

type QTextItem a = Object (CQTextItem a) #

type TQTextItem a = CQTextItem a #

data CQTextItem a #

qCast_QTextItem :: Object a -> IO (QTextItem ()) #

type QTextItemSc a = QTextItem (CQTextItemSc a) #

type TQTextItemSc a = TQTextItem (CQTextItemSc a) #

data CQTextItemSc a #

qCastList_QTextItem :: QqCastList_QTextItem a r => a -> r #

withQTextItemResult :: IO (Ptr (TQTextItem a)) -> IO (QTextItem a) #

type QTextDocumentFragment a = Object (CQTextDocumentFragment a) #

type TQTextDocumentFragment a = CQTextDocumentFragment a #

data CQTextDocumentFragment a #

qCast_QTextDocumentFragment :: Object a -> IO (QTextDocumentFragment ()) #

type QTextDocumentFragmentSc a = QTextDocumentFragment (CQTextDocumentFragmentSc a) #

type TQTextDocumentFragmentSc a = TQTextDocumentFragment (CQTextDocumentFragmentSc a) #

data CQTextDocumentFragmentSc a #

qCastList_QTextDocumentFragment :: QqCastList_QTextDocumentFragment a r => a -> r #

withQTextDocumentFragmentResult :: IO (Ptr (TQTextDocumentFragment a)) -> IO (QTextDocumentFragment a) #

type QVector3D a = Object (CQVector3D a) #

type TQVector3D a = CQVector3D a #

data CQVector3D a #

qCast_QVector3D :: Object a -> IO (QVector3D ()) #

type QVector3DSc a = QVector3D (CQVector3DSc a) #

type TQVector3DSc a = TQVector3D (CQVector3DSc a) #

data CQVector3DSc a #

qCastList_QVector3D :: QqCastList_QVector3D a r => a -> r #

withQVector3DResult :: IO (Ptr (TQVector3D a)) -> IO (QVector3D a) #

type QOpenGLVersionStatus a = Object (CQOpenGLVersionStatus a) #

type TQOpenGLVersionStatus a = CQOpenGLVersionStatus a #

data CQOpenGLVersionStatus a #

qCast_QOpenGLVersionStatus :: Object a -> IO (QOpenGLVersionStatus ()) #

type QOpenGLVersionStatusSc a = QOpenGLVersionStatus (CQOpenGLVersionStatusSc a) #

type TQOpenGLVersionStatusSc a = TQOpenGLVersionStatus (CQOpenGLVersionStatusSc a) #

data CQOpenGLVersionStatusSc a #

qCastList_QOpenGLVersionStatus :: QqCastList_QOpenGLVersionStatus a r => a -> r #

withQOpenGLVersionStatusResult :: IO (Ptr (TQOpenGLVersionStatus a)) -> IO (QOpenGLVersionStatus a) #

type QPlatformSurface a = Object (CQPlatformSurface a) #

type TQPlatformSurface a = CQPlatformSurface a #

data CQPlatformSurface a #

qCast_QPlatformSurface :: Object a -> IO (QPlatformSurface ()) #

type QPlatformSurfaceSc a = QPlatformSurface (CQPlatformSurfaceSc a) #

type TQPlatformSurfaceSc a = TQPlatformSurface (CQPlatformSurfaceSc a) #

data CQPlatformSurfaceSc a #

qCastList_QPlatformSurface :: QqCastList_QPlatformSurface a r => a -> r #

withQPlatformSurfaceResult :: IO (Ptr (TQPlatformSurface a)) -> IO (QPlatformSurface a) #

type QAbstractTextDocumentLayout_PaintContext a = Object (CQAbstractTextDocumentLayout_PaintContext a) #

type TQAbstractTextDocumentLayout_PaintContext a = CQAbstractTextDocumentLayout_PaintContext a #

data CQAbstractTextDocumentLayout_PaintContext a #

qCast_QAbstractTextDocumentLayout_PaintContext :: Object a -> IO (QAbstractTextDocumentLayout_PaintContext ()) #

type QAbstractTextDocumentLayout_PaintContextSc a = QAbstractTextDocumentLayout_PaintContext (CQAbstractTextDocumentLayout_PaintContextSc a) #

type TQAbstractTextDocumentLayout_PaintContextSc a = TQAbstractTextDocumentLayout_PaintContext (CQAbstractTextDocumentLayout_PaintContextSc a) #

data CQAbstractTextDocumentLayout_PaintContextSc a #

qCastList_QAbstractTextDocumentLayout_PaintContext :: QqCastList_QAbstractTextDocumentLayout_PaintContext a r => a -> r #

withQAbstractTextDocumentLayout_PaintContextResult :: IO (Ptr (TQAbstractTextDocumentLayout_PaintContext a)) -> IO (QAbstractTextDocumentLayout_PaintContext a) #

type QPlatformNativeInterface a = Object (CQPlatformNativeInterface a) #

type TQPlatformNativeInterface a = CQPlatformNativeInterface a #

data CQPlatformNativeInterface a #

qCast_QPlatformNativeInterface :: Object a -> IO (QPlatformNativeInterface ()) #

type QPlatformNativeInterfaceSc a = QPlatformNativeInterface (CQPlatformNativeInterfaceSc a) #

type TQPlatformNativeInterfaceSc a = TQPlatformNativeInterface (CQPlatformNativeInterfaceSc a) #

data CQPlatformNativeInterfaceSc a #

qCastList_QPlatformNativeInterface :: QqCastList_QPlatformNativeInterface a r => a -> r #

withQPlatformNativeInterfaceResult :: IO (Ptr (TQPlatformNativeInterface a)) -> IO (QPlatformNativeInterface a) #

type QPainter a = Object (CQPainter a) #

type TQPainter a = CQPainter a #

data CQPainter a #

qCast_QPainter :: Object a -> IO (QPainter ()) #

type QPainterSc a = QPainter (CQPainterSc a) #

type TQPainterSc a = TQPainter (CQPainterSc a) #

data CQPainterSc a #

qCastList_QPainter :: QqCastList_QPainter a r => a -> r #

withQPainterResult :: IO (Ptr (TQPainter a)) -> IO (QPainter a) #

type QAbstractUndoItem a = Object (CQAbstractUndoItem a) #

type TQAbstractUndoItem a = CQAbstractUndoItem a #

data CQAbstractUndoItem a #

qCast_QAbstractUndoItem :: Object a -> IO (QAbstractUndoItem ()) #

type QAbstractUndoItemSc a = QAbstractUndoItem (CQAbstractUndoItemSc a) #

type TQAbstractUndoItemSc a = TQAbstractUndoItem (CQAbstractUndoItemSc a) #

data CQAbstractUndoItemSc a #

qCastList_QAbstractUndoItem :: QqCastList_QAbstractUndoItem a r => a -> r #

withQAbstractUndoItemResult :: IO (Ptr (TQAbstractUndoItem a)) -> IO (QAbstractUndoItem a) #

type QPageLayout a = Object (CQPageLayout a) #

type TQPageLayout a = CQPageLayout a #

data CQPageLayout a #

qCast_QPageLayout :: Object a -> IO (QPageLayout ()) #

type QPageLayoutSc a = QPageLayout (CQPageLayoutSc a) #

type TQPageLayoutSc a = TQPageLayout (CQPageLayoutSc a) #

data CQPageLayoutSc a #

qCastList_QPageLayout :: QqCastList_QPageLayout a r => a -> r #

withQPageLayoutResult :: IO (Ptr (TQPageLayout a)) -> IO (QPageLayout a) #

type QPointingDeviceUniqueId a = Object (CQPointingDeviceUniqueId a) #

type TQPointingDeviceUniqueId a = CQPointingDeviceUniqueId a #

data CQPointingDeviceUniqueId a #

qCast_QPointingDeviceUniqueId :: Object a -> IO (QPointingDeviceUniqueId ()) #

type QPointingDeviceUniqueIdSc a = QPointingDeviceUniqueId (CQPointingDeviceUniqueIdSc a) #

type TQPointingDeviceUniqueIdSc a = TQPointingDeviceUniqueId (CQPointingDeviceUniqueIdSc a) #

data CQPointingDeviceUniqueIdSc a #

qCastList_QPointingDeviceUniqueId :: QqCastList_QPointingDeviceUniqueId a r => a -> r #

withQPointingDeviceUniqueIdResult :: IO (Ptr (TQPointingDeviceUniqueId a)) -> IO (QPointingDeviceUniqueId a) #

type QFontInfo a = Object (CQFontInfo a) #

type TQFontInfo a = CQFontInfo a #

data CQFontInfo a #

qCast_QFontInfo :: Object a -> IO (QFontInfo ()) #

type QFontInfoSc a = QFontInfo (CQFontInfoSc a) #

type TQFontInfoSc a = TQFontInfo (CQFontInfoSc a) #

data CQFontInfoSc a #

qCastList_QFontInfo :: QqCastList_QFontInfo a r => a -> r #

withQFontInfoResult :: IO (Ptr (TQFontInfo a)) -> IO (QFontInfo a) #

type QTextBlockUserData a = Object (CQTextBlockUserData a) #

type TQTextBlockUserData a = CQTextBlockUserData a #

data CQTextBlockUserData a #

qCast_QTextBlockUserData :: Object a -> IO (QTextBlockUserData ()) #

type QTextBlockUserDataSc a = QTextBlockUserData (CQTextBlockUserDataSc a) #

type TQTextBlockUserDataSc a = TQTextBlockUserData (CQTextBlockUserDataSc a) #

data CQTextBlockUserDataSc a #

qCastList_QTextBlockUserData :: QqCastList_QTextBlockUserData a r => a -> r #

withQTextBlockUserDataResult :: IO (Ptr (TQTextBlockUserData a)) -> IO (QTextBlockUserData a) #

type QTextFrameLayoutData a = Object (CQTextFrameLayoutData a) #

type TQTextFrameLayoutData a = CQTextFrameLayoutData a #

data CQTextFrameLayoutData a #

qCast_QTextFrameLayoutData :: Object a -> IO (QTextFrameLayoutData ()) #

type QTextFrameLayoutDataSc a = QTextFrameLayoutData (CQTextFrameLayoutDataSc a) #

type TQTextFrameLayoutDataSc a = TQTextFrameLayoutData (CQTextFrameLayoutDataSc a) #

data CQTextFrameLayoutDataSc a #

qCastList_QTextFrameLayoutData :: QqCastList_QTextFrameLayoutData a r => a -> r #

withQTextFrameLayoutDataResult :: IO (Ptr (TQTextFrameLayoutData a)) -> IO (QTextFrameLayoutData a) #

type QPageSize a = Object (CQPageSize a) #

type TQPageSize a = CQPageSize a #

data CQPageSize a #

qCast_QPageSize :: Object a -> IO (QPageSize ()) #

type QPageSizeSc a = QPageSize (CQPageSizeSc a) #

type TQPageSizeSc a = TQPageSize (CQPageSizeSc a) #

data CQPageSizeSc a #

qCastList_QPageSize :: QqCastList_QPageSize a r => a -> r #

withQPageSizeResult :: IO (Ptr (TQPageSize a)) -> IO (QPageSize a) #

withQListQPageSizeResult :: IO (Ptr (TQListQPageSize ())) -> IO [QPageSize ()] #

qPageSizeListFromPtrList :: [Ptr (TQPageSize a)] -> IO [QPageSize a] #

type QListQPageSize a = Object (CQListQPageSize a) #

type TQListQPageSize a = CQListQPageSize a #

data CQListQPageSize a #

type QRawFont a = Object (CQRawFont a) #

type TQRawFont a = CQRawFont a #

data CQRawFont a #

qCast_QRawFont :: Object a -> IO (QRawFont ()) #

type QRawFontSc a = QRawFont (CQRawFontSc a) #

type TQRawFontSc a = TQRawFont (CQRawFontSc a) #

data CQRawFontSc a #

qCastList_QRawFont :: QqCastList_QRawFont a r => a -> r #

withQRawFontResult :: IO (Ptr (TQRawFont a)) -> IO (QRawFont a) #

type QTextLayout_FormatRange a = Object (CQTextLayout_FormatRange a) #

type TQTextLayout_FormatRange a = CQTextLayout_FormatRange a #

data CQTextLayout_FormatRange a #

qCast_QTextLayout_FormatRange :: Object a -> IO (QTextLayout_FormatRange ()) #

type QTextLayout_FormatRangeSc a = QTextLayout_FormatRange (CQTextLayout_FormatRangeSc a) #

type TQTextLayout_FormatRangeSc a = TQTextLayout_FormatRange (CQTextLayout_FormatRangeSc a) #

data CQTextLayout_FormatRangeSc a #

qCastList_QTextLayout_FormatRange :: QqCastList_QTextLayout_FormatRange a r => a -> r #

withQTextLayout_FormatRangeResult :: IO (Ptr (TQTextLayout_FormatRange a)) -> IO (QTextLayout_FormatRange a) #

withQListQTextLayout_FormatRangeResult :: IO (Ptr (TQListQTextLayout_FormatRange ())) -> IO [QTextLayout_FormatRange ()] #

qTextLayout_FormatRangeListFromPtrList :: [Ptr (TQTextLayout_FormatRange a)] -> IO [QTextLayout_FormatRange a] #

type QListQTextLayout_FormatRange a = Object (CQListQTextLayout_FormatRange a) #

type TQListQTextLayout_FormatRange a = CQListQTextLayout_FormatRange a #

data CQListQTextLayout_FormatRange a #

withQVectorQTextLayout_FormatRangeResult :: IO (Ptr (TQVectorQTextLayout_FormatRange ())) -> IO [QTextLayout_FormatRange ()] #

qTextLayout_FormatRangeVectorFromPtrList :: [Ptr (TQTextLayout_FormatRange a)] -> IO [QTextLayout_FormatRange a] #

type QVectorQTextLayout_FormatRange a = Object (CQVectorQTextLayout_FormatRange a) #

type TQVectorQTextLayout_FormatRange a = CQVectorQTextLayout_FormatRange a #

data CQVectorQTextLayout_FormatRange a #

type QTextFragment a = Object (CQTextFragment a) #

type TQTextFragment a = CQTextFragment a #

data CQTextFragment a #

qCast_QTextFragment :: Object a -> IO (QTextFragment ()) #

type QTextFragmentSc a = QTextFragment (CQTextFragmentSc a) #

type TQTextFragmentSc a = TQTextFragment (CQTextFragmentSc a) #

data CQTextFragmentSc a #

qCastList_QTextFragment :: QqCastList_QTextFragment a r => a -> r #

withQTextFragmentResult :: IO (Ptr (TQTextFragment a)) -> IO (QTextFragment a) #

type QOpenGLBuffer a = Object (CQOpenGLBuffer a) #

type TQOpenGLBuffer a = CQOpenGLBuffer a #

data CQOpenGLBuffer a #

qCast_QOpenGLBuffer :: Object a -> IO (QOpenGLBuffer ()) #

type QOpenGLBufferSc a = QOpenGLBuffer (CQOpenGLBufferSc a) #

type TQOpenGLBufferSc a = TQOpenGLBuffer (CQOpenGLBufferSc a) #

data CQOpenGLBufferSc a #

qCastList_QOpenGLBuffer :: QqCastList_QOpenGLBuffer a r => a -> r #

withQOpenGLBufferResult :: IO (Ptr (TQOpenGLBuffer a)) -> IO (QOpenGLBuffer a) #

type QTextDocumentWriter a = Object (CQTextDocumentWriter a) #

type TQTextDocumentWriter a = CQTextDocumentWriter a #

data CQTextDocumentWriter a #

qCast_QTextDocumentWriter :: Object a -> IO (QTextDocumentWriter ()) #

type QTextDocumentWriterSc a = QTextDocumentWriter (CQTextDocumentWriterSc a) #

type TQTextDocumentWriterSc a = TQTextDocumentWriter (CQTextDocumentWriterSc a) #

data CQTextDocumentWriterSc a #

qCastList_QTextDocumentWriter :: QqCastList_QTextDocumentWriter a r => a -> r #

withQTextDocumentWriterResult :: IO (Ptr (TQTextDocumentWriter a)) -> IO (QTextDocumentWriter a) #

type QPagedPaintDevicePrivate a = Object (CQPagedPaintDevicePrivate a) #

type TQPagedPaintDevicePrivate a = CQPagedPaintDevicePrivate a #

data CQPagedPaintDevicePrivate a #

qCast_QPagedPaintDevicePrivate :: Object a -> IO (QPagedPaintDevicePrivate ()) #

type QPagedPaintDevicePrivateSc a = QPagedPaintDevicePrivate (CQPagedPaintDevicePrivateSc a) #

type TQPagedPaintDevicePrivateSc a = TQPagedPaintDevicePrivate (CQPagedPaintDevicePrivateSc a) #

data CQPagedPaintDevicePrivateSc a #

qCastList_QPagedPaintDevicePrivate :: QqCastList_QPagedPaintDevicePrivate a r => a -> r #

type QPagedPaintDevice_Margins a = Object (CQPagedPaintDevice_Margins a) #

type TQPagedPaintDevice_Margins a = CQPagedPaintDevice_Margins a #

data CQPagedPaintDevice_Margins a #

qCast_QPagedPaintDevice_Margins :: Object a -> IO (QPagedPaintDevice_Margins ()) #

type QPagedPaintDevice_MarginsSc a = QPagedPaintDevice_Margins (CQPagedPaintDevice_MarginsSc a) #

type TQPagedPaintDevice_MarginsSc a = TQPagedPaintDevice_Margins (CQPagedPaintDevice_MarginsSc a) #

data CQPagedPaintDevice_MarginsSc a #

qCastList_QPagedPaintDevice_Margins :: QqCastList_QPagedPaintDevice_Margins a r => a -> r #

withQPagedPaintDevice_MarginsResult :: IO (Ptr (TQPagedPaintDevice_Margins a)) -> IO (QPagedPaintDevice_Margins a) #

type QTextOption a = Object (CQTextOption a) #

type TQTextOption a = CQTextOption a #

data CQTextOption a #

qCast_QTextOption :: Object a -> IO (QTextOption ()) #

type QTextOptionSc a = QTextOption (CQTextOptionSc a) #

type TQTextOptionSc a = TQTextOption (CQTextOptionSc a) #

data CQTextOptionSc a #

qCastList_QTextOption :: QqCastList_QTextOption a r => a -> r #

withQTextOptionResult :: IO (Ptr (TQTextOption a)) -> IO (QTextOption a) #

type QTextObjectInterface a = Object (CQTextObjectInterface a) #

type TQTextObjectInterface a = CQTextObjectInterface a #

data CQTextObjectInterface a #

qCast_QTextObjectInterface :: Object a -> IO (QTextObjectInterface ()) #

type QTextObjectInterfaceSc a = QTextObjectInterface (CQTextObjectInterfaceSc a) #

type TQTextObjectInterfaceSc a = TQTextObjectInterface (CQTextObjectInterfaceSc a) #

data CQTextObjectInterfaceSc a #

qCastList_QTextObjectInterface :: QqCastList_QTextObjectInterface a r => a -> r #

withQTextObjectInterfaceResult :: IO (Ptr (TQTextObjectInterface a)) -> IO (QTextObjectInterface a) #

type QTextLength a = Object (CQTextLength a) #

type TQTextLength a = CQTextLength a #

data CQTextLength a #

qCast_QTextLength :: Object a -> IO (QTextLength ()) #

type QTextLengthSc a = QTextLength (CQTextLengthSc a) #

type TQTextLengthSc a = TQTextLength (CQTextLengthSc a) #

data CQTextLengthSc a #

qCastList_QTextLength :: QqCastList_QTextLength a r => a -> r #

withQTextLengthResult :: IO (Ptr (TQTextLength a)) -> IO (QTextLength a) #

withQVectorQTextLengthResult :: IO (Ptr (TQVectorQTextLength ())) -> IO [QTextLength ()] #

qTextLengthVectorFromPtrList :: [Ptr (TQTextLength a)] -> IO [QTextLength a] #

type QVectorQTextLength a = Object (CQVectorQTextLength a) #

type TQVectorQTextLength a = CQVectorQTextLength a #

data CQVectorQTextLength a #

type QTextCursor a = Object (CQTextCursor a) #

type TQTextCursor a = CQTextCursor a #

data CQTextCursor a #

qCast_QTextCursor :: Object a -> IO (QTextCursor ()) #

type QTextCursorSc a = QTextCursor (CQTextCursorSc a) #

type TQTextCursorSc a = TQTextCursor (CQTextCursorSc a) #

data CQTextCursorSc a #

qCastList_QTextCursor :: QqCastList_QTextCursor a r => a -> r #

withQTextCursorResult :: IO (Ptr (TQTextCursor a)) -> IO (QTextCursor a) #

type QPaintEngineState a = Object (CQPaintEngineState a) #

type TQPaintEngineState a = CQPaintEngineState a #

data CQPaintEngineState a #

qCast_QPaintEngineState :: Object a -> IO (QPaintEngineState ()) #

type QPaintEngineStateSc a = QPaintEngineState (CQPaintEngineStateSc a) #

type TQPaintEngineStateSc a = TQPaintEngineState (CQPaintEngineStateSc a) #

data CQPaintEngineStateSc a #

qCastList_QPaintEngineState :: QqCastList_QPaintEngineState a r => a -> r #

withQPaintEngineStateResult :: IO (Ptr (TQPaintEngineState a)) -> IO (QPaintEngineState a) #

type QKeySequencePrivate a = Object (CQKeySequencePrivate a) #

type TQKeySequencePrivate a = CQKeySequencePrivate a #

data CQKeySequencePrivate a #

qCast_QKeySequencePrivate :: Object a -> IO (QKeySequencePrivate ()) #

type QKeySequencePrivateSc a = QKeySequencePrivate (CQKeySequencePrivateSc a) #

type TQKeySequencePrivateSc a = TQKeySequencePrivate (CQKeySequencePrivateSc a) #

data CQKeySequencePrivateSc a #

qCastList_QKeySequencePrivate :: QqCastList_QKeySequencePrivate a r => a -> r #

type QGenericPluginFactory a = Object (CQGenericPluginFactory a) #

type TQGenericPluginFactory a = CQGenericPluginFactory a #

data CQGenericPluginFactory a #

qCast_QGenericPluginFactory :: Object a -> IO (QGenericPluginFactory ()) #

type QGenericPluginFactorySc a = QGenericPluginFactory (CQGenericPluginFactorySc a) #

type TQGenericPluginFactorySc a = TQGenericPluginFactory (CQGenericPluginFactorySc a) #

data CQGenericPluginFactorySc a #

qCastList_QGenericPluginFactory :: QqCastList_QGenericPluginFactory a r => a -> r #

withQGenericPluginFactoryResult :: IO (Ptr (TQGenericPluginFactory a)) -> IO (QGenericPluginFactory a) #

type QTextLayout a = Object (CQTextLayout a) #

type TQTextLayout a = CQTextLayout a #

data CQTextLayout a #

qCast_QTextLayout :: Object a -> IO (QTextLayout ()) #

type QTextLayoutSc a = QTextLayout (CQTextLayoutSc a) #

type TQTextLayoutSc a = TQTextLayout (CQTextLayoutSc a) #

data CQTextLayoutSc a #

qCastList_QTextLayout :: QqCastList_QTextLayout a r => a -> r #

withQTextLayoutResult :: IO (Ptr (TQTextLayout a)) -> IO (QTextLayout a) #

type QTextList a = Object (CQTextList a) #

type TQTextList a = CQTextList a #

data CQTextList a #

qCast_QTextList :: Object a -> IO (QTextList ()) #

type QTextListSc a = QTextList (CQTextListSc a) #

type TQTextListSc a = TQTextList (CQTextListSc a) #

data CQTextListSc a #

qCastList_QTextList :: QqCastList_QTextList a r => a -> r #

withQTextListResult :: IO (Ptr (TQTextList a)) -> IO (QTextList a) #

type QPlatformBackingStore a = Object (CQPlatformBackingStore a) #

type TQPlatformBackingStore a = CQPlatformBackingStore a #

data CQPlatformBackingStore a #

qCast_QPlatformBackingStore :: Object a -> IO (QPlatformBackingStore ()) #

type QPlatformBackingStoreSc a = QPlatformBackingStore (CQPlatformBackingStoreSc a) #

type TQPlatformBackingStoreSc a = TQPlatformBackingStore (CQPlatformBackingStoreSc a) #

data CQPlatformBackingStoreSc a #

qCastList_QPlatformBackingStore :: QqCastList_QPlatformBackingStore a r => a -> r #

withQPlatformBackingStoreResult :: IO (Ptr (TQPlatformBackingStore a)) -> IO (QPlatformBackingStore a) #

type QRgba64 a = Object (CQRgba64 a) #

type TQRgba64 a = CQRgba64 a #

data CQRgba64 a #

qCast_QRgba64 :: Object a -> IO (QRgba64 ()) #

type QRgba64Sc a = QRgba64 (CQRgba64Sc a) #

type TQRgba64Sc a = TQRgba64 (CQRgba64Sc a) #

data CQRgba64Sc a #

qCastList_QRgba64 :: QqCastList_QRgba64 a r => a -> r #

withQRgba64Result :: IO (Ptr (TQRgba64 a)) -> IO (QRgba64 a) #

type QPainterPathStroker a = Object (CQPainterPathStroker a) #

type TQPainterPathStroker a = CQPainterPathStroker a #

data CQPainterPathStroker a #

qCast_QPainterPathStroker :: Object a -> IO (QPainterPathStroker ()) #

type QPainterPathStrokerSc a = QPainterPathStroker (CQPainterPathStrokerSc a) #

type TQPainterPathStrokerSc a = TQPainterPathStroker (CQPainterPathStrokerSc a) #

data CQPainterPathStrokerSc a #

qCastList_QPainterPathStroker :: QqCastList_QPainterPathStroker a r => a -> r #

withQPainterPathStrokerResult :: IO (Ptr (TQPainterPathStroker a)) -> IO (QPainterPathStroker a) #

type QPlatformWindow a = Object (CQPlatformWindow a) #

type TQPlatformWindow a = CQPlatformWindow a #

data CQPlatformWindow a #

qCast_QPlatformWindow :: Object a -> IO (QPlatformWindow ()) #

type QPlatformWindowSc a = QPlatformWindow (CQPlatformWindowSc a) #

type TQPlatformWindowSc a = TQPlatformWindow (CQPlatformWindowSc a) #

data CQPlatformWindowSc a #

qCastList_QPlatformWindow :: QqCastList_QPlatformWindow a r => a -> r #

withQPlatformWindowResult :: IO (Ptr (TQPlatformWindow a)) -> IO (QPlatformWindow a) #

type QIconEngine a = Object (CQIconEngine a) #

type TQIconEngine a = CQIconEngine a #

data CQIconEngine a #

qCast_QIconEngine :: Object a -> IO (QIconEngine ()) #

type QIconEngineSc a = QIconEngine (CQIconEngineSc a) #

type TQIconEngineSc a = TQIconEngine (CQIconEngineSc a) #

data CQIconEngineSc a #

qCastList_QIconEngine :: QqCastList_QIconEngine a r => a -> r #

withQIconEngineResult :: IO (Ptr (TQIconEngine a)) -> IO (QIconEngine a) #

type QOpenGLDebugMessage a = Object (CQOpenGLDebugMessage a) #

type TQOpenGLDebugMessage a = CQOpenGLDebugMessage a #

data CQOpenGLDebugMessage a #

qCast_QOpenGLDebugMessage :: Object a -> IO (QOpenGLDebugMessage ()) #

type QOpenGLDebugMessageSc a = QOpenGLDebugMessage (CQOpenGLDebugMessageSc a) #

type TQOpenGLDebugMessageSc a = TQOpenGLDebugMessage (CQOpenGLDebugMessageSc a) #

data CQOpenGLDebugMessageSc a #

qCastList_QOpenGLDebugMessage :: QqCastList_QOpenGLDebugMessage a r => a -> r #

withQOpenGLDebugMessageResult :: IO (Ptr (TQOpenGLDebugMessage a)) -> IO (QOpenGLDebugMessage a) #

type QDesktopServices a = Object (CQDesktopServices a) #

type TQDesktopServices a = CQDesktopServices a #

data CQDesktopServices a #

qCast_QDesktopServices :: Object a -> IO (QDesktopServices ()) #

type QDesktopServicesSc a = QDesktopServices (CQDesktopServicesSc a) #

type TQDesktopServicesSc a = TQDesktopServices (CQDesktopServicesSc a) #

data CQDesktopServicesSc a #

qCastList_QDesktopServices :: QqCastList_QDesktopServices a r => a -> r #

withQDesktopServicesResult :: IO (Ptr (TQDesktopServices a)) -> IO (QDesktopServices a) #

type QOpenGLFramebufferObjectFormat a = Object (CQOpenGLFramebufferObjectFormat a) #

type TQOpenGLFramebufferObjectFormat a = CQOpenGLFramebufferObjectFormat a #

data CQOpenGLFramebufferObjectFormat a #

qCast_QOpenGLFramebufferObjectFormat :: Object a -> IO (QOpenGLFramebufferObjectFormat ()) #

type QOpenGLFramebufferObjectFormatSc a = QOpenGLFramebufferObjectFormat (CQOpenGLFramebufferObjectFormatSc a) #

type TQOpenGLFramebufferObjectFormatSc a = TQOpenGLFramebufferObjectFormat (CQOpenGLFramebufferObjectFormatSc a) #

data CQOpenGLFramebufferObjectFormatSc a #

qCastList_QOpenGLFramebufferObjectFormat :: QqCastList_QOpenGLFramebufferObjectFormat a r => a -> r #

withQOpenGLFramebufferObjectFormatResult :: IO (Ptr (TQOpenGLFramebufferObjectFormat a)) -> IO (QOpenGLFramebufferObjectFormat a) #

type QFontDatabase a = Object (CQFontDatabase a) #

type TQFontDatabase a = CQFontDatabase a #

data CQFontDatabase a #

qCast_QFontDatabase :: Object a -> IO (QFontDatabase ()) #

type QFontDatabaseSc a = QFontDatabase (CQFontDatabaseSc a) #

type TQFontDatabaseSc a = TQFontDatabase (CQFontDatabaseSc a) #

data CQFontDatabaseSc a #

qCastList_QFontDatabase :: QqCastList_QFontDatabase a r => a -> r #

withQFontDatabaseResult :: IO (Ptr (TQFontDatabase a)) -> IO (QFontDatabase a) #

type QPolygon a = Object (CQPolygon a) #

type TQPolygon a = CQPolygon a #

data CQPolygon a #

qCast_QPolygon :: Object a -> IO (QPolygon ()) #

type QPolygonSc a = QPolygon (CQPolygonSc a) #

type TQPolygonSc a = TQPolygon (CQPolygonSc a) #

data CQPolygonSc a #

qCastList_QPolygon :: QqCastList_QPolygon a r => a -> r #

withQPolygonResult :: IO (Ptr (TQPolygon a)) -> IO (QPolygon a) #

type QIconEngine_AvailableSizesArgument a = Object (CQIconEngine_AvailableSizesArgument a) #

type TQIconEngine_AvailableSizesArgument a = CQIconEngine_AvailableSizesArgument a #

data CQIconEngine_AvailableSizesArgument a #

qCast_QIconEngine_AvailableSizesArgument :: Object a -> IO (QIconEngine_AvailableSizesArgument ()) #

type QIconEngine_AvailableSizesArgumentSc a = QIconEngine_AvailableSizesArgument (CQIconEngine_AvailableSizesArgumentSc a) #

type TQIconEngine_AvailableSizesArgumentSc a = TQIconEngine_AvailableSizesArgument (CQIconEngine_AvailableSizesArgumentSc a) #

data CQIconEngine_AvailableSizesArgumentSc a #

qCastList_QIconEngine_AvailableSizesArgument :: QqCastList_QIconEngine_AvailableSizesArgument a r => a -> r #

withQIconEngine_AvailableSizesArgumentResult :: IO (Ptr (TQIconEngine_AvailableSizesArgument a)) -> IO (QIconEngine_AvailableSizesArgument a) #

type QPicturePrivate a = Object (CQPicturePrivate a) #

type TQPicturePrivate a = CQPicturePrivate a #

data CQPicturePrivate a #

qCast_QPicturePrivate :: Object a -> IO (QPicturePrivate ()) #

type QPicturePrivateSc a = QPicturePrivate (CQPicturePrivateSc a) #

type TQPicturePrivateSc a = TQPicturePrivate (CQPicturePrivateSc a) #

data CQPicturePrivateSc a #

qCastList_QPicturePrivate :: QqCastList_QPicturePrivate a r => a -> r #

type QAccessibleInterface a = Object (CQAccessibleInterface a) #

type TQAccessibleInterface a = CQAccessibleInterface a #

data CQAccessibleInterface a #

qCast_QAccessibleInterface :: Object a -> IO (QAccessibleInterface ()) #

type QAccessibleInterfaceSc a = QAccessibleInterface (CQAccessibleInterfaceSc a) #

type TQAccessibleInterfaceSc a = TQAccessibleInterface (CQAccessibleInterfaceSc a) #

data CQAccessibleInterfaceSc a #

qCastList_QAccessibleInterface :: QqCastList_QAccessibleInterface a r => a -> r #

withQAccessibleInterfaceResult :: IO (Ptr (TQAccessibleInterface a)) -> IO (QAccessibleInterface a) #

type QGlyphRun a = Object (CQGlyphRun a) #

type TQGlyphRun a = CQGlyphRun a #

data CQGlyphRun a #

qCast_QGlyphRun :: Object a -> IO (QGlyphRun ()) #

type QGlyphRunSc a = QGlyphRun (CQGlyphRunSc a) #

type TQGlyphRunSc a = TQGlyphRun (CQGlyphRunSc a) #

data CQGlyphRunSc a #

qCastList_QGlyphRun :: QqCastList_QGlyphRun a r => a -> r #

withQGlyphRunResult :: IO (Ptr (TQGlyphRun a)) -> IO (QGlyphRun a) #

withQListQGlyphRunResult :: IO (Ptr (TQListQGlyphRun ())) -> IO [QGlyphRun ()] #

qGlyphRunListFromPtrList :: [Ptr (TQGlyphRun a)] -> IO [QGlyphRun a] #

type QListQGlyphRun a = Object (CQListQGlyphRun a) #

type TQListQGlyphRun a = CQListQGlyphRun a #

data CQListQGlyphRun a #

type QPlatformOffscreenSurface a = Object (CQPlatformOffscreenSurface a) #

type TQPlatformOffscreenSurface a = CQPlatformOffscreenSurface a #

data CQPlatformOffscreenSurface a #

qCast_QPlatformOffscreenSurface :: Object a -> IO (QPlatformOffscreenSurface ()) #

type QPlatformOffscreenSurfaceSc a = QPlatformOffscreenSurface (CQPlatformOffscreenSurfaceSc a) #

type TQPlatformOffscreenSurfaceSc a = TQPlatformOffscreenSurface (CQPlatformOffscreenSurfaceSc a) #

data CQPlatformOffscreenSurfaceSc a #

qCastList_QPlatformOffscreenSurface :: QqCastList_QPlatformOffscreenSurface a r => a -> r #

withQPlatformOffscreenSurfaceResult :: IO (Ptr (TQPlatformOffscreenSurface a)) -> IO (QPlatformOffscreenSurface a) #

type QSurfaceFormat a = Object (CQSurfaceFormat a) #

type TQSurfaceFormat a = CQSurfaceFormat a #

data CQSurfaceFormat a #

qCast_QSurfaceFormat :: Object a -> IO (QSurfaceFormat ()) #

type QSurfaceFormatSc a = QSurfaceFormat (CQSurfaceFormatSc a) #

type TQSurfaceFormatSc a = TQSurfaceFormat (CQSurfaceFormatSc a) #

data CQSurfaceFormatSc a #

qCastList_QSurfaceFormat :: QqCastList_QSurfaceFormat a r => a -> r #

withQSurfaceFormatResult :: IO (Ptr (TQSurfaceFormat a)) -> IO (QSurfaceFormat a) #

type QTextOption_Tab a = Object (CQTextOption_Tab a) #

type TQTextOption_Tab a = CQTextOption_Tab a #

data CQTextOption_Tab a #

qCast_QTextOption_Tab :: Object a -> IO (QTextOption_Tab ()) #

type QTextOption_TabSc a = QTextOption_Tab (CQTextOption_TabSc a) #

type TQTextOption_TabSc a = TQTextOption_Tab (CQTextOption_TabSc a) #

data CQTextOption_TabSc a #

qCastList_QTextOption_Tab :: QqCastList_QTextOption_Tab a r => a -> r #

withQTextOption_TabResult :: IO (Ptr (TQTextOption_Tab a)) -> IO (QTextOption_Tab a) #

withQListQTextOption_TabResult :: IO (Ptr (TQListQTextOption_Tab ())) -> IO [QTextOption_Tab ()] #

qTextOption_TabListFromPtrList :: [Ptr (TQTextOption_Tab a)] -> IO [QTextOption_Tab a] #

type QListQTextOption_Tab a = Object (CQListQTextOption_Tab a) #

type TQListQTextOption_Tab a = CQListQTextOption_Tab a #

data CQListQTextOption_Tab a #

type QPainter_PixmapFragment a = Object (CQPainter_PixmapFragment a) #

type TQPainter_PixmapFragment a = CQPainter_PixmapFragment a #

data CQPainter_PixmapFragment a #

qCast_QPainter_PixmapFragment :: Object a -> IO (QPainter_PixmapFragment ()) #

type QPainter_PixmapFragmentSc a = QPainter_PixmapFragment (CQPainter_PixmapFragmentSc a) #

type TQPainter_PixmapFragmentSc a = TQPainter_PixmapFragment (CQPainter_PixmapFragmentSc a) #

data CQPainter_PixmapFragmentSc a #

qCastList_QPainter_PixmapFragment :: QqCastList_QPainter_PixmapFragment a r => a -> r #

withQPainter_PixmapFragmentResult :: IO (Ptr (TQPainter_PixmapFragment a)) -> IO (QPainter_PixmapFragment a) #

type QTextTableCell a = Object (CQTextTableCell a) #

type TQTextTableCell a = CQTextTableCell a #

data CQTextTableCell a #

qCast_QTextTableCell :: Object a -> IO (QTextTableCell ()) #

type QTextTableCellSc a = QTextTableCell (CQTextTableCellSc a) #

type TQTextTableCellSc a = TQTextTableCell (CQTextTableCellSc a) #

data CQTextTableCellSc a #

qCastList_QTextTableCell :: QqCastList_QTextTableCell a r => a -> r #

withQTextTableCellResult :: IO (Ptr (TQTextTableCell a)) -> IO (QTextTableCell a) #

type QPaintEngine a = Object (CQPaintEngine a) #

type TQPaintEngine a = CQPaintEngine a #

data CQPaintEngine a #

qCast_QPaintEngine :: Object a -> IO (QPaintEngine ()) #

type QPaintEngineSc a = QPaintEngine (CQPaintEngineSc a) #

type TQPaintEngineSc a = TQPaintEngine (CQPaintEngineSc a) #

data CQPaintEngineSc a #

qCastList_QPaintEngine :: QqCastList_QPaintEngine a r => a -> r #

withQPaintEngineResult :: IO (Ptr (TQPaintEngine a)) -> IO (QPaintEngine a) #

type QAbstractTextDocumentLayout_Selection a = Object (CQAbstractTextDocumentLayout_Selection a) #

type TQAbstractTextDocumentLayout_Selection a = CQAbstractTextDocumentLayout_Selection a #

data CQAbstractTextDocumentLayout_Selection a #

qCast_QAbstractTextDocumentLayout_Selection :: Object a -> IO (QAbstractTextDocumentLayout_Selection ()) #

type QAbstractTextDocumentLayout_SelectionSc a = QAbstractTextDocumentLayout_Selection (CQAbstractTextDocumentLayout_SelectionSc a) #

type TQAbstractTextDocumentLayout_SelectionSc a = TQAbstractTextDocumentLayout_Selection (CQAbstractTextDocumentLayout_SelectionSc a) #

data CQAbstractTextDocumentLayout_SelectionSc a #

qCastList_QAbstractTextDocumentLayout_Selection :: QqCastList_QAbstractTextDocumentLayout_Selection a r => a -> r #

withQAbstractTextDocumentLayout_SelectionResult :: IO (Ptr (TQAbstractTextDocumentLayout_Selection a)) -> IO (QAbstractTextDocumentLayout_Selection a) #

withQVectorQAbstractTextDocumentLayout_SelectionResult :: IO (Ptr (TQVectorQAbstractTextDocumentLayout_Selection ())) -> IO [QAbstractTextDocumentLayout_Selection ()] #

qAbstractTextDocumentLayout_SelectionVectorFromPtrList :: [Ptr (TQAbstractTextDocumentLayout_Selection a)] -> IO [QAbstractTextDocumentLayout_Selection a] #

type QVectorQAbstractTextDocumentLayout_Selection a = Object (CQVectorQAbstractTextDocumentLayout_Selection a) #

type TQVectorQAbstractTextDocumentLayout_Selection a = CQVectorQAbstractTextDocumentLayout_Selection a #

data CQVectorQAbstractTextDocumentLayout_Selection a #

type QPalette a = Object (CQPalette a) #

type TQPalette a = CQPalette a #

data CQPalette a #

qCast_QPalette :: Object a -> IO (QPalette ()) #

type QPaletteSc a = QPalette (CQPaletteSc a) #

type TQPaletteSc a = TQPalette (CQPaletteSc a) #

data CQPaletteSc a #

qCastList_QPalette :: QqCastList_QPalette a r => a -> r #

withQPaletteResult :: IO (Ptr (TQPalette a)) -> IO (QPalette a) #

type QStandardItemModel a = QAbstractItemModel (CQStandardItemModel a) #

type TQStandardItemModel a = TQAbstractItemModel (CQStandardItemModel a) #

data CQStandardItemModel a #

qCast_QStandardItemModel :: Object a -> IO (QStandardItemModel ()) #

type QStandardItemModelSc a = QStandardItemModel (CQStandardItemModelSc a) #

type TQStandardItemModelSc a = TQStandardItemModel (CQStandardItemModelSc a) #

data CQStandardItemModelSc a #

qCastList_QStandardItemModel :: QqCastList_QStandardItemModel a r => a -> r #

withQStandardItemModelResult :: IO (Ptr (TQStandardItemModel a)) -> IO (QStandardItemModel a) #

qStandardItemModelFromPtr :: Ptr (TQStandardItemModel a) -> IO (QStandardItemModel a) #

qStandardItemModelAddFinalizer :: QStandardItemModel a -> IO () #

type QGuiApplication a = QCoreApplication (CQGuiApplication a) #

type TQGuiApplication a = TQCoreApplication (CQGuiApplication a) #

data CQGuiApplication a #

qCast_QGuiApplication :: Object a -> IO (QGuiApplication ()) #

type QGuiApplicationSc a = QGuiApplication (CQGuiApplicationSc a) #

type TQGuiApplicationSc a = TQGuiApplication (CQGuiApplicationSc a) #

data CQGuiApplicationSc a #

qCastList_QGuiApplication :: QqCastList_QGuiApplication a r => a -> r #

withQGuiApplicationResult :: IO (Ptr (TQGuiApplication a)) -> IO (QGuiApplication a) #

qGuiApplicationFromPtr :: Ptr (TQGuiApplication a) -> IO (QGuiApplication a) #

qGuiApplicationAddFinalizer :: QGuiApplication a -> IO () #

type QHelpEvent a = QEvent (CQHelpEvent a) #

type TQHelpEvent a = TQEvent (CQHelpEvent a) #

data CQHelpEvent a #

qCast_QHelpEvent :: Object a -> IO (QHelpEvent ()) #

type QHelpEventSc a = QHelpEvent (CQHelpEventSc a) #

type TQHelpEventSc a = TQHelpEvent (CQHelpEventSc a) #

data CQHelpEventSc a #

qCastList_QHelpEvent :: QqCastList_QHelpEvent a r => a -> r #

withQHelpEventResult :: IO (Ptr (TQHelpEvent a)) -> IO (QHelpEvent a) #

type QStatusTipEvent a = QEvent (CQStatusTipEvent a) #

type TQStatusTipEvent a = TQEvent (CQStatusTipEvent a) #

data CQStatusTipEvent a #

qCast_QStatusTipEvent :: Object a -> IO (QStatusTipEvent ()) #

type QStatusTipEventSc a = QStatusTipEvent (CQStatusTipEventSc a) #

type TQStatusTipEventSc a = TQStatusTipEvent (CQStatusTipEventSc a) #

data CQStatusTipEventSc a #

qCastList_QStatusTipEvent :: QqCastList_QStatusTipEvent a r => a -> r #

withQStatusTipEventResult :: IO (Ptr (TQStatusTipEvent a)) -> IO (QStatusTipEvent a) #

type QIconDragEvent a = QEvent (CQIconDragEvent a) #

type TQIconDragEvent a = TQEvent (CQIconDragEvent a) #

data CQIconDragEvent a #

qCast_QIconDragEvent :: Object a -> IO (QIconDragEvent ()) #

type QIconDragEventSc a = QIconDragEvent (CQIconDragEventSc a) #

type TQIconDragEventSc a = TQIconDragEvent (CQIconDragEventSc a) #

data CQIconDragEventSc a #

qCastList_QIconDragEvent :: QqCastList_QIconDragEvent a r => a -> r #

withQIconDragEventResult :: IO (Ptr (TQIconDragEvent a)) -> IO (QIconDragEvent a) #

type QResizeEvent a = QEvent (CQResizeEvent a) #

type TQResizeEvent a = TQEvent (CQResizeEvent a) #

data CQResizeEvent a #

qCast_QResizeEvent :: Object a -> IO (QResizeEvent ()) #

type QResizeEventSc a = QResizeEvent (CQResizeEventSc a) #

type TQResizeEventSc a = TQResizeEvent (CQResizeEventSc a) #

data CQResizeEventSc a #

qCastList_QResizeEvent :: QqCastList_QResizeEvent a r => a -> r #

withQResizeEventResult :: IO (Ptr (TQResizeEvent a)) -> IO (QResizeEvent a) #

type QScrollEvent a = QEvent (CQScrollEvent a) #

type TQScrollEvent a = TQEvent (CQScrollEvent a) #

data CQScrollEvent a #

qCast_QScrollEvent :: Object a -> IO (QScrollEvent ()) #

type QScrollEventSc a = QScrollEvent (CQScrollEventSc a) #

type TQScrollEventSc a = TQScrollEvent (CQScrollEventSc a) #

data CQScrollEventSc a #

qCastList_QScrollEvent :: QqCastList_QScrollEvent a r => a -> r #

type QScrollPrepareEvent a = QEvent (CQScrollPrepareEvent a) #

type TQScrollPrepareEvent a = TQEvent (CQScrollPrepareEvent a) #

data CQScrollPrepareEvent a #

qCast_QScrollPrepareEvent :: Object a -> IO (QScrollPrepareEvent ()) #

type QScrollPrepareEventSc a = QScrollPrepareEvent (CQScrollPrepareEventSc a) #

type TQScrollPrepareEventSc a = TQScrollPrepareEvent (CQScrollPrepareEventSc a) #

data CQScrollPrepareEventSc a #

qCastList_QScrollPrepareEvent :: QqCastList_QScrollPrepareEvent a r => a -> r #

type QMoveEvent a = QEvent (CQMoveEvent a) #

type TQMoveEvent a = TQEvent (CQMoveEvent a) #

data CQMoveEvent a #

qCast_QMoveEvent :: Object a -> IO (QMoveEvent ()) #

type QMoveEventSc a = QMoveEvent (CQMoveEventSc a) #

type TQMoveEventSc a = TQMoveEvent (CQMoveEventSc a) #

data CQMoveEventSc a #

qCastList_QMoveEvent :: QqCastList_QMoveEvent a r => a -> r #

withQMoveEventResult :: IO (Ptr (TQMoveEvent a)) -> IO (QMoveEvent a) #

type QExposeEvent a = QEvent (CQExposeEvent a) #

type TQExposeEvent a = TQEvent (CQExposeEvent a) #

data CQExposeEvent a #

qCast_QExposeEvent :: Object a -> IO (QExposeEvent ()) #

type QExposeEventSc a = QExposeEvent (CQExposeEventSc a) #

type TQExposeEventSc a = TQExposeEvent (CQExposeEventSc a) #

data CQExposeEventSc a #

qCastList_QExposeEvent :: QqCastList_QExposeEvent a r => a -> r #

withQExposeEventResult :: IO (Ptr (TQExposeEvent a)) -> IO (QExposeEvent a) #

type QFocusEvent a = QEvent (CQFocusEvent a) #

type TQFocusEvent a = TQEvent (CQFocusEvent a) #

data CQFocusEvent a #

qCast_QFocusEvent :: Object a -> IO (QFocusEvent ()) #

type QFocusEventSc a = QFocusEvent (CQFocusEventSc a) #

type TQFocusEventSc a = TQFocusEvent (CQFocusEventSc a) #

data CQFocusEventSc a #

qCastList_QFocusEvent :: QqCastList_QFocusEvent a r => a -> r #

withQFocusEventResult :: IO (Ptr (TQFocusEvent a)) -> IO (QFocusEvent a) #

type QInputMethodEvent a = QEvent (CQInputMethodEvent a) #

type TQInputMethodEvent a = TQEvent (CQInputMethodEvent a) #

data CQInputMethodEvent a #

qCast_QInputMethodEvent :: Object a -> IO (QInputMethodEvent ()) #

type QInputMethodEventSc a = QInputMethodEvent (CQInputMethodEventSc a) #

type TQInputMethodEventSc a = TQInputMethodEvent (CQInputMethodEventSc a) #

data CQInputMethodEventSc a #

qCastList_QInputMethodEvent :: QqCastList_QInputMethodEvent a r => a -> r #

withQInputMethodEventResult :: IO (Ptr (TQInputMethodEvent a)) -> IO (QInputMethodEvent a) #

type QActionEvent a = QEvent (CQActionEvent a) #

type TQActionEvent a = TQEvent (CQActionEvent a) #

data CQActionEvent a #

qCast_QActionEvent :: Object a -> IO (QActionEvent ()) #

type QActionEventSc a = QActionEvent (CQActionEventSc a) #

type TQActionEventSc a = TQActionEvent (CQActionEventSc a) #

data CQActionEventSc a #

qCastList_QActionEvent :: QqCastList_QActionEvent a r => a -> r #

withQActionEventResult :: IO (Ptr (TQActionEvent a)) -> IO (QActionEvent a) #

type QInputMethodQueryEvent a = QEvent (CQInputMethodQueryEvent a) #

type TQInputMethodQueryEvent a = TQEvent (CQInputMethodQueryEvent a) #

data CQInputMethodQueryEvent a #

qCast_QInputMethodQueryEvent :: Object a -> IO (QInputMethodQueryEvent ()) #

type QInputMethodQueryEventSc a = QInputMethodQueryEvent (CQInputMethodQueryEventSc a) #

type TQInputMethodQueryEventSc a = TQInputMethodQueryEvent (CQInputMethodQueryEventSc a) #

data CQInputMethodQueryEventSc a #

qCastList_QInputMethodQueryEvent :: QqCastList_QInputMethodQueryEvent a r => a -> r #

withQInputMethodQueryEventResult :: IO (Ptr (TQInputMethodQueryEvent a)) -> IO (QInputMethodQueryEvent a) #

type QShowEvent a = QEvent (CQShowEvent a) #

type TQShowEvent a = TQEvent (CQShowEvent a) #

data CQShowEvent a #

qCast_QShowEvent :: Object a -> IO (QShowEvent ()) #

type QShowEventSc a = QShowEvent (CQShowEventSc a) #

type TQShowEventSc a = TQShowEvent (CQShowEventSc a) #

data CQShowEventSc a #

qCastList_QShowEvent :: QqCastList_QShowEvent a r => a -> r #

withQShowEventResult :: IO (Ptr (TQShowEvent a)) -> IO (QShowEvent a) #

type QPaintEvent a = QEvent (CQPaintEvent a) #

type TQPaintEvent a = TQEvent (CQPaintEvent a) #

data CQPaintEvent a #

qCast_QPaintEvent :: Object a -> IO (QPaintEvent ()) #

type QPaintEventSc a = QPaintEvent (CQPaintEventSc a) #

type TQPaintEventSc a = TQPaintEvent (CQPaintEventSc a) #

data CQPaintEventSc a #

qCastList_QPaintEvent :: QqCastList_QPaintEvent a r => a -> r #

withQPaintEventResult :: IO (Ptr (TQPaintEvent a)) -> IO (QPaintEvent a) #

type QWindowStateChangeEvent a = QEvent (CQWindowStateChangeEvent a) #

type TQWindowStateChangeEvent a = TQEvent (CQWindowStateChangeEvent a) #

data CQWindowStateChangeEvent a #

qCast_QWindowStateChangeEvent :: Object a -> IO (QWindowStateChangeEvent ()) #

type QWindowStateChangeEventSc a = QWindowStateChangeEvent (CQWindowStateChangeEventSc a) #

type TQWindowStateChangeEventSc a = TQWindowStateChangeEvent (CQWindowStateChangeEventSc a) #

data CQWindowStateChangeEventSc a #

qCastList_QWindowStateChangeEvent :: QqCastList_QWindowStateChangeEvent a r => a -> r #