Documentation

qCast_QWidget :: Object a -> IO (QWidget ()) #

type QWidgetSc a = QWidget (CQWidgetSc a) #

type TQWidgetSc a = TQWidget (CQWidgetSc a) #

data CQWidgetSc a #

qCastList_QWidget :: QqCastList_QWidget a r => a -> r #

withQWidgetResult :: IO (Ptr (TQWidget a)) -> IO (QWidget a) #

qWidgetFromPtr :: Ptr (TQWidget a) -> IO (QWidget a) #

qWidgetAddFinalizer :: QWidget a -> IO () #

withQListQWidgetResult :: IO (Ptr (TQListQWidget ())) -> IO [QWidget ()] #

qWidgetListFromPtrList :: [Ptr (TQWidget a)] -> IO [QWidget a] #

type QListQWidget a = Object (CQListQWidget a) #

type TQListQWidget a = CQListQWidget a #

data CQListQWidget a #

type QStyleOption a = Object (CQStyleOption a) #

type TQStyleOption a = CQStyleOption a #

data CQStyleOption a #

qCast_QStyleOption :: Object a -> IO (QStyleOption ()) #

type QStyleOptionSc a = QStyleOption (CQStyleOptionSc a) #

type TQStyleOptionSc a = TQStyleOption (CQStyleOptionSc a) #

data CQStyleOptionSc a #

qCastList_QStyleOption :: QqCastList_QStyleOption a r => a -> r #

withQStyleOptionResult :: IO (Ptr (TQStyleOption a)) -> IO (QStyleOption a) #

type QFrame a = QWidget (CQFrame a) #

type TQFrame a = TQWidget (CQFrame a) #

data CQFrame a #

qCast_QFrame :: Object a -> IO (QFrame ()) #

type QFrameSc a = QFrame (CQFrameSc a) #

type TQFrameSc a = TQFrame (CQFrameSc a) #

data CQFrameSc a #

qCastList_QFrame :: QqCastList_QFrame a r => a -> r #

withQFrameResult :: IO (Ptr (TQFrame a)) -> IO (QFrame a) #

qFrameFromPtr :: Ptr (TQFrame a) -> IO (QFrame a) #

qFrameAddFinalizer :: QFrame a -> IO () #

type QAbstractScrollArea a = QFrame (CQAbstractScrollArea a) #

type TQAbstractScrollArea a = TQFrame (CQAbstractScrollArea a) #

data CQAbstractScrollArea a #

qCast_QAbstractScrollArea :: Object a -> IO (QAbstractScrollArea ()) #

type QAbstractScrollAreaSc a = QAbstractScrollArea (CQAbstractScrollAreaSc a) #

type TQAbstractScrollAreaSc a = TQAbstractScrollArea (CQAbstractScrollAreaSc a) #

data CQAbstractScrollAreaSc a #

qCastList_QAbstractScrollArea :: QqCastList_QAbstractScrollArea a r => a -> r #

withQAbstractScrollAreaResult :: IO (Ptr (TQAbstractScrollArea a)) -> IO (QAbstractScrollArea a) #

qAbstractScrollAreaFromPtr :: Ptr (TQAbstractScrollArea a) -> IO (QAbstractScrollArea a) #

qAbstractScrollAreaAddFinalizer :: QAbstractScrollArea a -> IO () #

type QGraphicsItem a = Object (CQGraphicsItem a) #

type TQGraphicsItem a = CQGraphicsItem a #

data CQGraphicsItem a #

qCast_QGraphicsItem :: Object a -> IO (QGraphicsItem ()) #

type QGraphicsItemSc a = QGraphicsItem (CQGraphicsItemSc a) #

type TQGraphicsItemSc a = TQGraphicsItem (CQGraphicsItemSc a) #

data CQGraphicsItemSc a #

qCastList_QGraphicsItem :: QqCastList_QGraphicsItem a r => a -> r #

withQGraphicsItemResult :: IO (Ptr (TQGraphicsItem a)) -> IO (QGraphicsItem a) #

withQListQGraphicsItemResult :: IO (Ptr (TQListQGraphicsItem ())) -> IO [QGraphicsItem ()] #

qGraphicsItemListFromPtrList :: [Ptr (TQGraphicsItem a)] -> IO [QGraphicsItem a] #

type QListQGraphicsItem a = Object (CQListQGraphicsItem a) #

type TQListQGraphicsItem a = CQListQGraphicsItem a #

data CQListQGraphicsItem a #

type QLayoutItem a = Object (CQLayoutItem a) #

type TQLayoutItem a = CQLayoutItem a #

data CQLayoutItem a #

qCast_QLayoutItem :: Object a -> IO (QLayoutItem ()) #

type QLayoutItemSc a = QLayoutItem (CQLayoutItemSc a) #

type TQLayoutItemSc a = TQLayoutItem (CQLayoutItemSc a) #

data CQLayoutItemSc a #

qCastList_QLayoutItem :: QqCastList_QLayoutItem a r => a -> r #

withQLayoutItemResult :: IO (Ptr (TQLayoutItem a)) -> IO (QLayoutItem a) #

type QAbstractItemView a = QAbstractScrollArea (CQAbstractItemView a) #

type TQAbstractItemView a = TQAbstractScrollArea (CQAbstractItemView a) #

data CQAbstractItemView a #

qCast_QAbstractItemView :: Object a -> IO (QAbstractItemView ()) #

type QAbstractItemViewSc a = QAbstractItemView (CQAbstractItemViewSc a) #

type TQAbstractItemViewSc a = TQAbstractItemView (CQAbstractItemViewSc a) #

data CQAbstractItemViewSc a #

qCastList_QAbstractItemView :: QqCastList_QAbstractItemView a r => a -> r #

withQAbstractItemViewResult :: IO (Ptr (TQAbstractItemView a)) -> IO (QAbstractItemView a) #

qAbstractItemViewFromPtr :: Ptr (TQAbstractItemView a) -> IO (QAbstractItemView a) #

qAbstractItemViewAddFinalizer :: QAbstractItemView a -> IO () #

type QGraphicsSceneEvent a = QEvent (CQGraphicsSceneEvent a) #

type TQGraphicsSceneEvent a = TQEvent (CQGraphicsSceneEvent a) #

data CQGraphicsSceneEvent a #

qCast_QGraphicsSceneEvent :: Object a -> IO (QGraphicsSceneEvent ()) #

type QGraphicsSceneEventSc a = QGraphicsSceneEvent (CQGraphicsSceneEventSc a) #

type TQGraphicsSceneEventSc a = TQGraphicsSceneEvent (CQGraphicsSceneEventSc a) #

data CQGraphicsSceneEventSc a #

qCastList_QGraphicsSceneEvent :: QqCastList_QGraphicsSceneEvent a r => a -> r #

withQGraphicsSceneEventResult :: IO (Ptr (TQGraphicsSceneEvent a)) -> IO (QGraphicsSceneEvent a) #

type QDialog a = QWidget (CQDialog a) #

type TQDialog a = TQWidget (CQDialog a) #

data CQDialog a #

qCast_QDialog :: Object a -> IO (QDialog ()) #

type QDialogSc a = QDialog (CQDialogSc a) #

type TQDialogSc a = TQDialog (CQDialogSc a) #

data CQDialogSc a #

qCastList_QDialog :: QqCastList_QDialog a r => a -> r #

withQDialogResult :: IO (Ptr (TQDialog a)) -> IO (QDialog a) #

qDialogFromPtr :: Ptr (TQDialog a) -> IO (QDialog a) #

qDialogAddFinalizer :: QDialog a -> IO () #

type QStyleOptionComplex a = QStyleOption (CQStyleOptionComplex a) #

type TQStyleOptionComplex a = TQStyleOption (CQStyleOptionComplex a) #

data CQStyleOptionComplex a #

qCast_QStyleOptionComplex :: Object a -> IO (QStyleOptionComplex ()) #

type QStyleOptionComplexSc a = QStyleOptionComplex (CQStyleOptionComplexSc a) #

type TQStyleOptionComplexSc a = TQStyleOptionComplex (CQStyleOptionComplexSc a) #

data CQStyleOptionComplexSc a #

qCastList_QStyleOptionComplex :: QqCastList_QStyleOptionComplex a r => a -> r #

withQStyleOptionComplexResult :: IO (Ptr (TQStyleOptionComplex a)) -> IO (QStyleOptionComplex a) #

type QGraphicsLayoutItem a = Object (CQGraphicsLayoutItem a) #

type TQGraphicsLayoutItem a = CQGraphicsLayoutItem a #

data CQGraphicsLayoutItem a #

qCast_QGraphicsLayoutItem :: Object a -> IO (QGraphicsLayoutItem ()) #

type QGraphicsLayoutItemSc a = QGraphicsLayoutItem (CQGraphicsLayoutItemSc a) #

type TQGraphicsLayoutItemSc a = TQGraphicsLayoutItem (CQGraphicsLayoutItemSc a) #

data CQGraphicsLayoutItemSc a #

qCastList_QGraphicsLayoutItem :: QqCastList_QGraphicsLayoutItem a r => a -> r #

withQGraphicsLayoutItemResult :: IO (Ptr (TQGraphicsLayoutItem a)) -> IO (QGraphicsLayoutItem a) #

type QLayout a = QObject (CQLayout a) #

type TQLayout a = TQObject (CQLayout a) #

data CQLayout a #

qCast_QLayout :: Object a -> IO (QLayout ()) #

type QLayoutSc a = QLayout (CQLayoutSc a) #

type TQLayoutSc a = TQLayout (CQLayoutSc a) #

data CQLayoutSc a #

qCastList_QLayout :: QqCastList_QLayout a r => a -> r #

withQLayoutResult :: IO (Ptr (TQLayout a)) -> IO (QLayout a) #

qLayoutFromPtr :: Ptr (TQLayout a) -> IO (QLayout a) #

qLayoutAddFinalizer :: QLayout a -> IO () #

type QGesture a = QObject (CQGesture a) #

type TQGesture a = TQObject (CQGesture a) #

data CQGesture a #

qCast_QGesture :: Object a -> IO (QGesture ()) #

type QGestureSc a = QGesture (CQGestureSc a) #

type TQGestureSc a = TQGesture (CQGestureSc a) #

data CQGestureSc a #

qCastList_QGesture :: QqCastList_QGesture a r => a -> r #

withQGestureResult :: IO (Ptr (TQGesture a)) -> IO (QGesture a) #

qGestureFromPtr :: Ptr (TQGesture a) -> IO (QGesture a) #

qGestureAddFinalizer :: QGesture a -> IO () #

withQListQGestureResult :: IO (Ptr (TQListQGesture ())) -> IO [QGesture ()] #

qGestureListFromPtrList :: [Ptr (TQGesture a)] -> IO [QGesture a] #

type QListQGesture a = Object (CQListQGesture a) #

type TQListQGesture a = CQListQGesture a #

data CQListQGesture a #

type QAbstractButton a = QWidget (CQAbstractButton a) #

type TQAbstractButton a = TQWidget (CQAbstractButton a) #

data CQAbstractButton a #

qCast_QAbstractButton :: Object a -> IO (QAbstractButton ()) #

type QAbstractButtonSc a = QAbstractButton (CQAbstractButtonSc a) #

type TQAbstractButtonSc a = TQAbstractButton (CQAbstractButtonSc a) #

data CQAbstractButtonSc a #

qCastList_QAbstractButton :: QqCastList_QAbstractButton a r => a -> r #

withQAbstractButtonResult :: IO (Ptr (TQAbstractButton a)) -> IO (QAbstractButton a) #

qAbstractButtonFromPtr :: Ptr (TQAbstractButton a) -> IO (QAbstractButton a) #

qAbstractButtonAddFinalizer :: QAbstractButton a -> IO () #

withQListQAbstractButtonResult :: IO (Ptr (TQListQAbstractButton ())) -> IO [QAbstractButton ()] #

qAbstractButtonListFromPtrList :: [Ptr (TQAbstractButton a)] -> IO [QAbstractButton a] #

type QListQAbstractButton a = Object (CQListQAbstractButton a) #

type TQListQAbstractButton a = CQListQAbstractButton a #

data CQListQAbstractButton a #

type QAbstractSpinBox a = QWidget (CQAbstractSpinBox a) #

type TQAbstractSpinBox a = TQWidget (CQAbstractSpinBox a) #

data CQAbstractSpinBox a #

qCast_QAbstractSpinBox :: Object a -> IO (QAbstractSpinBox ()) #

type QAbstractSpinBoxSc a = QAbstractSpinBox (CQAbstractSpinBoxSc a) #

type TQAbstractSpinBoxSc a = TQAbstractSpinBox (CQAbstractSpinBoxSc a) #

data CQAbstractSpinBoxSc a #

qCastList_QAbstractSpinBox :: QqCastList_QAbstractSpinBox a r => a -> r #

withQAbstractSpinBoxResult :: IO (Ptr (TQAbstractSpinBox a)) -> IO (QAbstractSpinBox a) #

qAbstractSpinBoxFromPtr :: Ptr (TQAbstractSpinBox a) -> IO (QAbstractSpinBox a) #

qAbstractSpinBoxAddFinalizer :: QAbstractSpinBox a -> IO () #

type QAbstractGraphicsShapeItem a = QGraphicsItem (CQAbstractGraphicsShapeItem a) #

type TQAbstractGraphicsShapeItem a = TQGraphicsItem (CQAbstractGraphicsShapeItem a) #

data CQAbstractGraphicsShapeItem a #

qCast_QAbstractGraphicsShapeItem :: Object a -> IO (QAbstractGraphicsShapeItem ()) #

type QAbstractGraphicsShapeItemSc a = QAbstractGraphicsShapeItem (CQAbstractGraphicsShapeItemSc a) #

type TQAbstractGraphicsShapeItemSc a = TQAbstractGraphicsShapeItem (CQAbstractGraphicsShapeItemSc a) #

data CQAbstractGraphicsShapeItemSc a #

qCastList_QAbstractGraphicsShapeItem :: QqCastList_QAbstractGraphicsShapeItem a r => a -> r #

withQAbstractGraphicsShapeItemResult :: IO (Ptr (TQAbstractGraphicsShapeItem a)) -> IO (QAbstractGraphicsShapeItem a) #

type QGraphicsEffect a = QObject (CQGraphicsEffect a) #

type TQGraphicsEffect a = TQObject (CQGraphicsEffect a) #

data CQGraphicsEffect a #

qCast_QGraphicsEffect :: Object a -> IO (QGraphicsEffect ()) #

type QGraphicsEffectSc a = QGraphicsEffect (CQGraphicsEffectSc a) #

type TQGraphicsEffectSc a = TQGraphicsEffect (CQGraphicsEffectSc a) #

data CQGraphicsEffectSc a #

qCastList_QGraphicsEffect :: QqCastList_QGraphicsEffect a r => a -> r #

withQGraphicsEffectResult :: IO (Ptr (TQGraphicsEffect a)) -> IO (QGraphicsEffect a) #

qGraphicsEffectFromPtr :: Ptr (TQGraphicsEffect a) -> IO (QGraphicsEffect a) #

qGraphicsEffectAddFinalizer :: QGraphicsEffect a -> IO () #

type QGraphicsObject a = QObject (CQGraphicsObject a) #

type TQGraphicsObject a = TQObject (CQGraphicsObject a) #

data CQGraphicsObject a #

qCast_QGraphicsObject :: Object a -> IO (QGraphicsObject ()) #

type QGraphicsObjectSc a = QGraphicsObject (CQGraphicsObjectSc a) #

type TQGraphicsObjectSc a = TQGraphicsObject (CQGraphicsObjectSc a) #

data CQGraphicsObjectSc a #

qCastList_QGraphicsObject :: QqCastList_QGraphicsObject a r => a -> r #

withQGraphicsObjectResult :: IO (Ptr (TQGraphicsObject a)) -> IO (QGraphicsObject a) #

qGraphicsObjectFromPtr :: Ptr (TQGraphicsObject a) -> IO (QGraphicsObject a) #

qGraphicsObjectAddFinalizer :: QGraphicsObject a -> IO () #

type QAbstractSlider a = QWidget (CQAbstractSlider a) #

type TQAbstractSlider a = TQWidget (CQAbstractSlider a) #

data CQAbstractSlider a #

qCast_QAbstractSlider :: Object a -> IO (QAbstractSlider ()) #

type QAbstractSliderSc a = QAbstractSlider (CQAbstractSliderSc a) #

type TQAbstractSliderSc a = TQAbstractSlider (CQAbstractSliderSc a) #

data CQAbstractSliderSc a #

qCastList_QAbstractSlider :: QqCastList_QAbstractSlider a r => a -> r #

withQAbstractSliderResult :: IO (Ptr (TQAbstractSlider a)) -> IO (QAbstractSlider a) #

qAbstractSliderFromPtr :: Ptr (TQAbstractSlider a) -> IO (QAbstractSlider a) #

qAbstractSliderAddFinalizer :: QAbstractSlider a -> IO () #

type QGraphicsLayout a = QGraphicsLayoutItem (CQGraphicsLayout a) #

type TQGraphicsLayout a = TQGraphicsLayoutItem (CQGraphicsLayout a) #

data CQGraphicsLayout a #

qCast_QGraphicsLayout :: Object a -> IO (QGraphicsLayout ()) #

type QGraphicsLayoutSc a = QGraphicsLayout (CQGraphicsLayoutSc a) #

type TQGraphicsLayoutSc a = TQGraphicsLayout (CQGraphicsLayoutSc a) #

data CQGraphicsLayoutSc a #

qCastList_QGraphicsLayout :: QqCastList_QGraphicsLayout a r => a -> r #

withQGraphicsLayoutResult :: IO (Ptr (TQGraphicsLayout a)) -> IO (QGraphicsLayout a) #

type QStyleHintReturn a = Object (CQStyleHintReturn a) #

type TQStyleHintReturn a = CQStyleHintReturn a #

data CQStyleHintReturn a #

qCast_QStyleHintReturn :: Object a -> IO (QStyleHintReturn ()) #

type QStyleHintReturnSc a = QStyleHintReturn (CQStyleHintReturnSc a) #

type TQStyleHintReturnSc a = TQStyleHintReturn (CQStyleHintReturnSc a) #

data CQStyleHintReturnSc a #

qCastList_QStyleHintReturn :: QqCastList_QStyleHintReturn a r => a -> r #

withQStyleHintReturnResult :: IO (Ptr (TQStyleHintReturn a)) -> IO (QStyleHintReturn a) #

type QStyle a = QObject (CQStyle a) #

type TQStyle a = TQObject (CQStyle a) #

data CQStyle a #

qCast_QStyle :: Object a -> IO (QStyle ()) #

type QStyleSc a = QStyle (CQStyleSc a) #

type TQStyleSc a = TQStyle (CQStyleSc a) #

data CQStyleSc a #

qCastList_QStyle :: QqCastList_QStyle a r => a -> r #

withQStyleResult :: IO (Ptr (TQStyle a)) -> IO (QStyle a) #

qStyleFromPtr :: Ptr (TQStyle a) -> IO (QStyle a) #

qStyleAddFinalizer :: QStyle a -> IO () #

type QGraphicsTransform a = QObject (CQGraphicsTransform a) #

type TQGraphicsTransform a = TQObject (CQGraphicsTransform a) #

data CQGraphicsTransform a #

qCast_QGraphicsTransform :: Object a -> IO (QGraphicsTransform ()) #

type QGraphicsTransformSc a = QGraphicsTransform (CQGraphicsTransformSc a) #

type TQGraphicsTransformSc a = TQGraphicsTransform (CQGraphicsTransformSc a) #

data CQGraphicsTransformSc a #

qCastList_QGraphicsTransform :: QqCastList_QGraphicsTransform a r => a -> r #

withQGraphicsTransformResult :: IO (Ptr (TQGraphicsTransform a)) -> IO (QGraphicsTransform a) #

qGraphicsTransformFromPtr :: Ptr (TQGraphicsTransform a) -> IO (QGraphicsTransform a) #

qGraphicsTransformAddFinalizer :: QGraphicsTransform a -> IO () #

withQListQGraphicsTransformResult :: IO (Ptr (TQListQGraphicsTransform ())) -> IO [QGraphicsTransform ()] #

qGraphicsTransformListFromPtrList :: [Ptr (TQGraphicsTransform a)] -> IO [QGraphicsTransform a] #

type QListQGraphicsTransform a = Object (CQListQGraphicsTransform a) #

type TQListQGraphicsTransform a = CQListQGraphicsTransform a #

data CQListQGraphicsTransform a #

type QAbstractItemDelegate a = QObject (CQAbstractItemDelegate a) #

type TQAbstractItemDelegate a = TQObject (CQAbstractItemDelegate a) #

data CQAbstractItemDelegate a #

qCast_QAbstractItemDelegate :: Object a -> IO (QAbstractItemDelegate ()) #

type QAbstractItemDelegateSc a = QAbstractItemDelegate (CQAbstractItemDelegateSc a) #

type TQAbstractItemDelegateSc a = TQAbstractItemDelegate (CQAbstractItemDelegateSc a) #

data CQAbstractItemDelegateSc a #

qCastList_QAbstractItemDelegate :: QqCastList_QAbstractItemDelegate a r => a -> r #

withQAbstractItemDelegateResult :: IO (Ptr (TQAbstractItemDelegate a)) -> IO (QAbstractItemDelegate a) #

qAbstractItemDelegateFromPtr :: Ptr (TQAbstractItemDelegate a) -> IO (QAbstractItemDelegate a) #

qAbstractItemDelegateAddFinalizer :: QAbstractItemDelegate a -> IO () #

type QListView a = QAbstractItemView (CQListView a) #

type TQListView a = TQAbstractItemView (CQListView a) #

data CQListView a #

qCast_QListView :: Object a -> IO (QListView ()) #

type QListViewSc a = QListView (CQListViewSc a) #

type TQListViewSc a = TQListView (CQListViewSc a) #

data CQListViewSc a #

qCastList_QListView :: QqCastList_QListView a r => a -> r #

withQListViewResult :: IO (Ptr (TQListView a)) -> IO (QListView a) #

qListViewFromPtr :: Ptr (TQListView a) -> IO (QListView a) #

qListViewAddFinalizer :: QListView a -> IO () #

type QDateTimeEdit a = QAbstractSpinBox (CQDateTimeEdit a) #

type TQDateTimeEdit a = TQAbstractSpinBox (CQDateTimeEdit a) #

data CQDateTimeEdit a #

qCast_QDateTimeEdit :: Object a -> IO (QDateTimeEdit ()) #

type QDateTimeEditSc a = QDateTimeEdit (CQDateTimeEditSc a) #

type TQDateTimeEditSc a = TQDateTimeEdit (CQDateTimeEditSc a) #

data CQDateTimeEditSc a #

qCastList_QDateTimeEdit :: QqCastList_QDateTimeEdit a r => a -> r #

withQDateTimeEditResult :: IO (Ptr (TQDateTimeEdit a)) -> IO (QDateTimeEdit a) #

qDateTimeEditFromPtr :: Ptr (TQDateTimeEdit a) -> IO (QDateTimeEdit a) #

qDateTimeEditAddFinalizer :: QDateTimeEdit a -> IO () #

type QBoxLayout a = QLayout (CQBoxLayout a) #

type TQBoxLayout a = TQLayout (CQBoxLayout a) #

data CQBoxLayout a #

qCast_QBoxLayout :: Object a -> IO (QBoxLayout ()) #

type QBoxLayoutSc a = QBoxLayout (CQBoxLayoutSc a) #

type TQBoxLayoutSc a = TQBoxLayout (CQBoxLayoutSc a) #

data CQBoxLayoutSc a #

qCastList_QBoxLayout :: QqCastList_QBoxLayout a r => a -> r #

withQBoxLayoutResult :: IO (Ptr (TQBoxLayout a)) -> IO (QBoxLayout a) #

qBoxLayoutFromPtr :: Ptr (TQBoxLayout a) -> IO (QBoxLayout a) #

qBoxLayoutAddFinalizer :: QBoxLayout a -> IO () #

qCast_QAction :: Object a -> IO (QAction ()) #

type QActionSc a = QAction (CQActionSc a) #

type TQActionSc a = TQAction (CQActionSc a) #

data CQActionSc a #

qCastList_QAction :: QqCastList_QAction a r => a -> r #

withQActionResult :: IO (Ptr (TQAction a)) -> IO (QAction a) #

qActionFromPtr :: Ptr (TQAction a) -> IO (QAction a) #

qActionAddFinalizer :: QAction a -> IO () #

withQListQActionResult :: IO (Ptr (TQListQAction ())) -> IO [QAction ()] #

qActionListFromPtrList :: [Ptr (TQAction a)] -> IO [QAction a] #

type QListQAction a = Object (CQListQAction a) #

type TQListQAction a = CQListQAction a #

data CQListQAction a #

type QComboBox a = QWidget (CQComboBox a) #

type TQComboBox a = TQWidget (CQComboBox a) #

data CQComboBox a #

qCast_QComboBox :: Object a -> IO (QComboBox ()) #

type QComboBoxSc a = QComboBox (CQComboBoxSc a) #

type TQComboBoxSc a = TQComboBox (CQComboBoxSc a) #

data CQComboBoxSc a #

qCastList_QComboBox :: QqCastList_QComboBox a r => a -> r #

withQComboBoxResult :: IO (Ptr (TQComboBox a)) -> IO (QComboBox a) #

qComboBoxFromPtr :: Ptr (TQComboBox a) -> IO (QComboBox a) #

qComboBoxAddFinalizer :: QComboBox a -> IO () #

type QPushButton a = QAbstractButton (CQPushButton a) #

type TQPushButton a = TQAbstractButton (CQPushButton a) #

data CQPushButton a #

qCast_QPushButton :: Object a -> IO (QPushButton ()) #

type QPushButtonSc a = QPushButton (CQPushButtonSc a) #

type TQPushButtonSc a = TQPushButton (CQPushButtonSc a) #

data CQPushButtonSc a #

qCastList_QPushButton :: QqCastList_QPushButton a r => a -> r #

withQPushButtonResult :: IO (Ptr (TQPushButton a)) -> IO (QPushButton a) #

qPushButtonFromPtr :: Ptr (TQPushButton a) -> IO (QPushButton a) #

qPushButtonAddFinalizer :: QPushButton a -> IO () #

type QTreeView a = QAbstractItemView (CQTreeView a) #

type TQTreeView a = TQAbstractItemView (CQTreeView a) #

data CQTreeView a #

qCast_QTreeView :: Object a -> IO (QTreeView ()) #

type QTreeViewSc a = QTreeView (CQTreeViewSc a) #

type TQTreeViewSc a = TQTreeView (CQTreeViewSc a) #

data CQTreeViewSc a #

qCastList_QTreeView :: QqCastList_QTreeView a r => a -> r #

withQTreeViewResult :: IO (Ptr (TQTreeView a)) -> IO (QTreeView a) #

qTreeViewFromPtr :: Ptr (TQTreeView a) -> IO (QTreeView a) #

qTreeViewAddFinalizer :: QTreeView a -> IO () #

type QTableView a = QAbstractItemView (CQTableView a) #

type TQTableView a = TQAbstractItemView (CQTableView a) #

data CQTableView a #

qCast_QTableView :: Object a -> IO (QTableView ()) #

type QTableViewSc a = QTableView (CQTableViewSc a) #

type TQTableViewSc a = TQTableView (CQTableViewSc a) #

data CQTableViewSc a #

qCastList_QTableView :: QqCastList_QTableView a r => a -> r #

withQTableViewResult :: IO (Ptr (TQTableView a)) -> IO (QTableView a) #

qTableViewFromPtr :: Ptr (TQTableView a) -> IO (QTableView a) #

qTableViewAddFinalizer :: QTableView a -> IO () #

type QTextEdit a = QAbstractScrollArea (CQTextEdit a) #

type TQTextEdit a = TQAbstractScrollArea (CQTextEdit a) #

data CQTextEdit a #

qCast_QTextEdit :: Object a -> IO (QTextEdit ()) #

type QTextEditSc a = QTextEdit (CQTextEditSc a) #

type TQTextEditSc a = TQTextEdit (CQTextEditSc a) #

data CQTextEditSc a #

qCastList_QTextEdit :: QqCastList_QTextEdit a r => a -> r #

withQTextEditResult :: IO (Ptr (TQTextEdit a)) -> IO (QTextEdit a) #

qTextEditFromPtr :: Ptr (TQTextEdit a) -> IO (QTextEdit a) #

qTextEditAddFinalizer :: QTextEdit a -> IO () #

type QGraphicsWidget a = QGraphicsObject (CQGraphicsWidget a) #

type TQGraphicsWidget a = TQGraphicsObject (CQGraphicsWidget a) #

data CQGraphicsWidget a #

qCast_QGraphicsWidget :: Object a -> IO (QGraphicsWidget ()) #

type QGraphicsWidgetSc a = QGraphicsWidget (CQGraphicsWidgetSc a) #

type TQGraphicsWidgetSc a = TQGraphicsWidget (CQGraphicsWidgetSc a) #

data CQGraphicsWidgetSc a #

qCastList_QGraphicsWidget :: QqCastList_QGraphicsWidget a r => a -> r #

withQGraphicsWidgetResult :: IO (Ptr (TQGraphicsWidget a)) -> IO (QGraphicsWidget a) #

qGraphicsWidgetFromPtr :: Ptr (TQGraphicsWidget a) -> IO (QGraphicsWidget a) #

qGraphicsWidgetAddFinalizer :: QGraphicsWidget a -> IO () #

withQListQGraphicsWidgetResult :: IO (Ptr (TQListQGraphicsWidget ())) -> IO [QGraphicsWidget ()] #

qGraphicsWidgetListFromPtrList :: [Ptr (TQGraphicsWidget a)] -> IO [QGraphicsWidget a] #

type QListQGraphicsWidget a = Object (CQListQGraphicsWidget a) #

type TQListQGraphicsWidget a = CQListQGraphicsWidget a #

data CQListQGraphicsWidget a #

type QCommonStyle a = QStyle (CQCommonStyle a) #

type TQCommonStyle a = TQStyle (CQCommonStyle a) #

data CQCommonStyle a #

qCast_QCommonStyle :: Object a -> IO (QCommonStyle ()) #

type QCommonStyleSc a = QCommonStyle (CQCommonStyleSc a) #

type TQCommonStyleSc a = TQCommonStyle (CQCommonStyleSc a) #

data CQCommonStyleSc a #

qCastList_QCommonStyle :: QqCastList_QCommonStyle a r => a -> r #

withQCommonStyleResult :: IO (Ptr (TQCommonStyle a)) -> IO (QCommonStyle a) #

qCommonStyleFromPtr :: Ptr (TQCommonStyle a) -> IO (QCommonStyle a) #

qCommonStyleAddFinalizer :: QCommonStyle a -> IO () #

type QTreeWidgetItem a = Object (CQTreeWidgetItem a) #

type TQTreeWidgetItem a = CQTreeWidgetItem a #

data CQTreeWidgetItem a #

qCast_QTreeWidgetItem :: Object a -> IO (QTreeWidgetItem ()) #

type QTreeWidgetItemSc a = QTreeWidgetItem (CQTreeWidgetItemSc a) #

type TQTreeWidgetItemSc a = TQTreeWidgetItem (CQTreeWidgetItemSc a) #

data CQTreeWidgetItemSc a #

qCastList_QTreeWidgetItem :: QqCastList_QTreeWidgetItem a r => a -> r #

withQTreeWidgetItemResult :: IO (Ptr (TQTreeWidgetItem a)) -> IO (QTreeWidgetItem a) #

withQListQTreeWidgetItemResult :: IO (Ptr (TQListQTreeWidgetItem ())) -> IO [QTreeWidgetItem ()] #

qTreeWidgetItemListFromPtrList :: [Ptr (TQTreeWidgetItem a)] -> IO [QTreeWidgetItem a] #

type QListQTreeWidgetItem a = Object (CQListQTreeWidgetItem a) #

type TQListQTreeWidgetItem a = CQListQTreeWidgetItem a #

data CQListQTreeWidgetItem a #

type QItemEditorCreatorBase a = Object (CQItemEditorCreatorBase a) #

type TQItemEditorCreatorBase a = CQItemEditorCreatorBase a #

data CQItemEditorCreatorBase a #

qCast_QItemEditorCreatorBase :: Object a -> IO (QItemEditorCreatorBase ()) #

type QItemEditorCreatorBaseSc a = QItemEditorCreatorBase (CQItemEditorCreatorBaseSc a) #

type TQItemEditorCreatorBaseSc a = TQItemEditorCreatorBase (CQItemEditorCreatorBaseSc a) #

data CQItemEditorCreatorBaseSc a #

qCastList_QItemEditorCreatorBase :: QqCastList_QItemEditorCreatorBase a r => a -> r #

withQItemEditorCreatorBaseResult :: IO (Ptr (TQItemEditorCreatorBase a)) -> IO (QItemEditorCreatorBase a) #

type QFileDialogArgs a = Object (CQFileDialogArgs a) #

type TQFileDialogArgs a = CQFileDialogArgs a #

data CQFileDialogArgs a #

qCast_QFileDialogArgs :: Object a -> IO (QFileDialogArgs ()) #

type QFileDialogArgsSc a = QFileDialogArgs (CQFileDialogArgsSc a) #

type TQFileDialogArgsSc a = TQFileDialogArgs (CQFileDialogArgsSc a) #

data CQFileDialogArgsSc a #

qCastList_QFileDialogArgs :: QqCastList_QFileDialogArgs a r => a -> r #

withQFileDialogArgsResult :: IO (Ptr (TQFileDialogArgs a)) -> IO (QFileDialogArgs a) #

type QGraphicsEffectSource a = Object (CQGraphicsEffectSource a) #

type TQGraphicsEffectSource a = CQGraphicsEffectSource a #

data CQGraphicsEffectSource a #

qCast_QGraphicsEffectSource :: Object a -> IO (QGraphicsEffectSource ()) #

type QGraphicsEffectSourceSc a = QGraphicsEffectSource (CQGraphicsEffectSourceSc a) #

type TQGraphicsEffectSourceSc a = TQGraphicsEffectSource (CQGraphicsEffectSourceSc a) #

data CQGraphicsEffectSourceSc a #

qCastList_QGraphicsEffectSource :: QqCastList_QGraphicsEffectSource a r => a -> r #

withQGraphicsEffectSourceResult :: IO (Ptr (TQGraphicsEffectSource a)) -> IO (QGraphicsEffectSource a) #

type QTileRules a = Object (CQTileRules a) #

type TQTileRules a = CQTileRules a #

data CQTileRules a #

qCast_QTileRules :: Object a -> IO (QTileRules ()) #

type QTileRulesSc a = QTileRules (CQTileRulesSc a) #

type TQTileRulesSc a = TQTileRules (CQTileRulesSc a) #

data CQTileRulesSc a #

qCastList_QTileRules :: QqCastList_QTileRules a r => a -> r #

withQTileRulesResult :: IO (Ptr (TQTileRules a)) -> IO (QTileRules a) #

type QGraphicsSceneEventPrivate a = Object (CQGraphicsSceneEventPrivate a) #

type TQGraphicsSceneEventPrivate a = CQGraphicsSceneEventPrivate a #

data CQGraphicsSceneEventPrivate a #

qCast_QGraphicsSceneEventPrivate :: Object a -> IO (QGraphicsSceneEventPrivate ()) #

type QGraphicsSceneEventPrivateSc a = QGraphicsSceneEventPrivate (CQGraphicsSceneEventPrivateSc a) #

type TQGraphicsSceneEventPrivateSc a = TQGraphicsSceneEventPrivate (CQGraphicsSceneEventPrivateSc a) #

data CQGraphicsSceneEventPrivateSc a #

qCastList_QGraphicsSceneEventPrivate :: QqCastList_QGraphicsSceneEventPrivate a r => a -> r #

withQGraphicsSceneEventPrivateResult :: IO (Ptr (TQGraphicsSceneEventPrivate a)) -> IO (QGraphicsSceneEventPrivate a) #

type QColormap a = Object (CQColormap a) #

type TQColormap a = CQColormap a #

data CQColormap a #

qCast_QColormap :: Object a -> IO (QColormap ()) #

type QColormapSc a = QColormap (CQColormapSc a) #

type TQColormapSc a = TQColormap (CQColormapSc a) #

data CQColormapSc a #

qCastList_QColormap :: QqCastList_QColormap a r => a -> r #

withQColormapResult :: IO (Ptr (TQColormap a)) -> IO (QColormap a) #

type QSizePolicy a = Object (CQSizePolicy a) #

type TQSizePolicy a = CQSizePolicy a #

data CQSizePolicy a #

qCast_QSizePolicy :: Object a -> IO (QSizePolicy ()) #

type QSizePolicySc a = QSizePolicy (CQSizePolicySc a) #

type TQSizePolicySc a = TQSizePolicy (CQSizePolicySc a) #

data CQSizePolicySc a #

qCastList_QSizePolicy :: QqCastList_QSizePolicy a r => a -> r #

withQSizePolicyResult :: IO (Ptr (TQSizePolicy a)) -> IO (QSizePolicy a) #

type QTreeWidgetItemIterator a = Object (CQTreeWidgetItemIterator a) #

type TQTreeWidgetItemIterator a = CQTreeWidgetItemIterator a #

data CQTreeWidgetItemIterator a #

qCast_QTreeWidgetItemIterator :: Object a -> IO (QTreeWidgetItemIterator ()) #

type QTreeWidgetItemIteratorSc a = QTreeWidgetItemIterator (CQTreeWidgetItemIteratorSc a) #

type TQTreeWidgetItemIteratorSc a = TQTreeWidgetItemIterator (CQTreeWidgetItemIteratorSc a) #

data CQTreeWidgetItemIteratorSc a #

qCastList_QTreeWidgetItemIterator :: QqCastList_QTreeWidgetItemIterator a r => a -> r #

withQTreeWidgetItemIteratorResult :: IO (Ptr (TQTreeWidgetItemIterator a)) -> IO (QTreeWidgetItemIterator a) #

type QTableWidgetItem a = Object (CQTableWidgetItem a) #

type TQTableWidgetItem a = CQTableWidgetItem a #

data CQTableWidgetItem a #

qCast_QTableWidgetItem :: Object a -> IO (QTableWidgetItem ()) #

type QTableWidgetItemSc a = QTableWidgetItem (CQTableWidgetItemSc a) #

type TQTableWidgetItemSc a = TQTableWidgetItem (CQTableWidgetItemSc a) #

data CQTableWidgetItemSc a #

qCastList_QTableWidgetItem :: QqCastList_QTableWidgetItem a r => a -> r #

withQTableWidgetItemResult :: IO (Ptr (TQTableWidgetItem a)) -> IO (QTableWidgetItem a) #

withQListQTableWidgetItemResult :: IO (Ptr (TQListQTableWidgetItem ())) -> IO [QTableWidgetItem ()] #

qTableWidgetItemListFromPtrList :: [Ptr (TQTableWidgetItem a)] -> IO [QTableWidgetItem a] #

type QListQTableWidgetItem a = Object (CQListQTableWidgetItem a) #

type TQListQTableWidgetItem a = CQListQTableWidgetItem a #

data CQListQTableWidgetItem a #

type QTabletEvent a = Object (CQTabletEvent a) #

type TQTabletEvent a = CQTabletEvent a #

data CQTabletEvent a #

qCast_QTabletEvent :: Object a -> IO (QTabletEvent ()) #

type QTabletEventSc a = QTabletEvent (CQTabletEventSc a) #

type TQTabletEventSc a = TQTabletEvent (CQTabletEventSc a) #

data CQTabletEventSc a #

qCastList_QTabletEvent :: QqCastList_QTabletEvent a r => a -> r #

withQTabletEventResult :: IO (Ptr (TQTabletEvent a)) -> IO (QTabletEvent a) #

type QPlatformMenuBar a = Object (CQPlatformMenuBar a) #

type TQPlatformMenuBar a = CQPlatformMenuBar a #

data CQPlatformMenuBar a #

qCast_QPlatformMenuBar :: Object a -> IO (QPlatformMenuBar ()) #

type QPlatformMenuBarSc a = QPlatformMenuBar (CQPlatformMenuBarSc a) #

type TQPlatformMenuBarSc a = TQPlatformMenuBar (CQPlatformMenuBarSc a) #

data CQPlatformMenuBarSc a #

qCastList_QPlatformMenuBar :: QqCastList_QPlatformMenuBar a r => a -> r #

withQPlatformMenuBarResult :: IO (Ptr (TQPlatformMenuBar a)) -> IO (QPlatformMenuBar a) #

type QTextEdit_ExtraSelection a = Object (CQTextEdit_ExtraSelection a) #

type TQTextEdit_ExtraSelection a = CQTextEdit_ExtraSelection a #

data CQTextEdit_ExtraSelection a #

qCast_QTextEdit_ExtraSelection :: Object a -> IO (QTextEdit_ExtraSelection ()) #

type QTextEdit_ExtraSelectionSc a = QTextEdit_ExtraSelection (CQTextEdit_ExtraSelectionSc a) #

type TQTextEdit_ExtraSelectionSc a = TQTextEdit_ExtraSelection (CQTextEdit_ExtraSelectionSc a) #

data CQTextEdit_ExtraSelectionSc a #

qCastList_QTextEdit_ExtraSelection :: QqCastList_QTextEdit_ExtraSelection a r => a -> r #

withQTextEdit_ExtraSelectionResult :: IO (Ptr (TQTextEdit_ExtraSelection a)) -> IO (QTextEdit_ExtraSelection a) #

withQListQTextEdit_ExtraSelectionResult :: IO (Ptr (TQListQTextEdit_ExtraSelection ())) -> IO [QTextEdit_ExtraSelection ()] #

qTextEdit_ExtraSelectionListFromPtrList :: [Ptr (TQTextEdit_ExtraSelection a)] -> IO [QTextEdit_ExtraSelection a] #

type QListQTextEdit_ExtraSelection a = Object (CQListQTextEdit_ExtraSelection a) #

type TQListQTextEdit_ExtraSelection a = CQListQTextEdit_ExtraSelection a #

data CQListQTextEdit_ExtraSelection a #

type QScrollerProperties a = Object (CQScrollerProperties a) #

type TQScrollerProperties a = CQScrollerProperties a #

data CQScrollerProperties a #

qCast_QScrollerProperties :: Object a -> IO (QScrollerProperties ()) #

type QScrollerPropertiesSc a = QScrollerProperties (CQScrollerPropertiesSc a) #

type TQScrollerPropertiesSc a = TQScrollerProperties (CQScrollerPropertiesSc a) #

data CQScrollerPropertiesSc a #

qCastList_QScrollerProperties :: QqCastList_QScrollerProperties a r => a -> r #

withQScrollerPropertiesResult :: IO (Ptr (TQScrollerProperties a)) -> IO (QScrollerProperties a) #

type QListWidgetItem a = Object (CQListWidgetItem a) #

type TQListWidgetItem a = CQListWidgetItem a #

data CQListWidgetItem a #

qCast_QListWidgetItem :: Object a -> IO (QListWidgetItem ()) #

type QListWidgetItemSc a = QListWidgetItem (CQListWidgetItemSc a) #

type TQListWidgetItemSc a = TQListWidgetItem (CQListWidgetItemSc a) #

data CQListWidgetItemSc a #

qCastList_QListWidgetItem :: QqCastList_QListWidgetItem a r => a -> r #

withQListWidgetItemResult :: IO (Ptr (TQListWidgetItem a)) -> IO (QListWidgetItem a) #

withQListQListWidgetItemResult :: IO (Ptr (TQListQListWidgetItem ())) -> IO [QListWidgetItem ()] #

qListWidgetItemListFromPtrList :: [Ptr (TQListWidgetItem a)] -> IO [QListWidgetItem a] #

type QListQListWidgetItem a = Object (CQListQListWidgetItem a) #

type TQListQListWidgetItem a = CQListQListWidgetItem a #

data CQListQListWidgetItem a #

type QGestureRecognizer a = Object (CQGestureRecognizer a) #

type TQGestureRecognizer a = CQGestureRecognizer a #

data CQGestureRecognizer a #

qCast_QGestureRecognizer :: Object a -> IO (QGestureRecognizer ()) #

type QGestureRecognizerSc a = QGestureRecognizer (CQGestureRecognizerSc a) #

type TQGestureRecognizerSc a = TQGestureRecognizer (CQGestureRecognizerSc a) #

data CQGestureRecognizerSc a #

qCastList_QGestureRecognizer :: QqCastList_QGestureRecognizer a r => a -> r #

withQGestureRecognizerResult :: IO (Ptr (TQGestureRecognizer a)) -> IO (QGestureRecognizer a) #

type QPlatformMenu a = Object (CQPlatformMenu a) #

type TQPlatformMenu a = CQPlatformMenu a #

data CQPlatformMenu a #

qCast_QPlatformMenu :: Object a -> IO (QPlatformMenu ()) #

type QPlatformMenuSc a = QPlatformMenu (CQPlatformMenuSc a) #

type TQPlatformMenuSc a = TQPlatformMenu (CQPlatformMenuSc a) #

data CQPlatformMenuSc a #

qCastList_QPlatformMenu :: QqCastList_QPlatformMenu a r => a -> r #

withQPlatformMenuResult :: IO (Ptr (TQPlatformMenu a)) -> IO (QPlatformMenu a) #

type QWheelEvent a = Object (CQWheelEvent a) #

type TQWheelEvent a = CQWheelEvent a #

data CQWheelEvent a #

qCast_QWheelEvent :: Object a -> IO (QWheelEvent ()) #

type QWheelEventSc a = QWheelEvent (CQWheelEventSc a) #

type TQWheelEventSc a = TQWheelEvent (CQWheelEventSc a) #

data CQWheelEventSc a #

qCastList_QWheelEvent :: QqCastList_QWheelEvent a r => a -> r #

withQWheelEventResult :: IO (Ptr (TQWheelEvent a)) -> IO (QWheelEvent a) #

type QItemEditorFactory a = Object (CQItemEditorFactory a) #

type TQItemEditorFactory a = CQItemEditorFactory a #

data CQItemEditorFactory a #

qCast_QItemEditorFactory :: Object a -> IO (QItemEditorFactory ()) #

type QItemEditorFactorySc a = QItemEditorFactory (CQItemEditorFactorySc a) #

type TQItemEditorFactorySc a = TQItemEditorFactory (CQItemEditorFactorySc a) #

data CQItemEditorFactorySc a #

qCastList_QItemEditorFactory :: QqCastList_QItemEditorFactory a r => a -> r #

withQItemEditorFactoryResult :: IO (Ptr (TQItemEditorFactory a)) -> IO (QItemEditorFactory a) #

type QFormLayout_TakeRowResult a = Object (CQFormLayout_TakeRowResult a) #

type TQFormLayout_TakeRowResult a = CQFormLayout_TakeRowResult a #

data CQFormLayout_TakeRowResult a #

qCast_QFormLayout_TakeRowResult :: Object a -> IO (QFormLayout_TakeRowResult ()) #

type QFormLayout_TakeRowResultSc a = QFormLayout_TakeRowResult (CQFormLayout_TakeRowResultSc a) #

type TQFormLayout_TakeRowResultSc a = TQFormLayout_TakeRowResult (CQFormLayout_TakeRowResultSc a) #

data CQFormLayout_TakeRowResultSc a #

qCastList_QFormLayout_TakeRowResult :: QqCastList_QFormLayout_TakeRowResult a r => a -> r #

withQFormLayout_TakeRowResultResult :: IO (Ptr (TQFormLayout_TakeRowResult a)) -> IO (QFormLayout_TakeRowResult a) #

type QWhatsThis a = Object (CQWhatsThis a) #

type TQWhatsThis a = CQWhatsThis a #

data CQWhatsThis a #

qCast_QWhatsThis :: Object a -> IO (QWhatsThis ()) #

type QWhatsThisSc a = QWhatsThis (CQWhatsThisSc a) #

type TQWhatsThisSc a = TQWhatsThis (CQWhatsThisSc a) #

data CQWhatsThisSc a #

qCastList_QWhatsThis :: QqCastList_QWhatsThis a r => a -> r #

withQWhatsThisResult :: IO (Ptr (TQWhatsThis a)) -> IO (QWhatsThis a) #

type QUndoCommand a = Object (CQUndoCommand a) #

type TQUndoCommand a = CQUndoCommand a #

data CQUndoCommand a #

qCast_QUndoCommand :: Object a -> IO (QUndoCommand ()) #

type QUndoCommandSc a = QUndoCommand (CQUndoCommandSc a) #

type TQUndoCommandSc a = TQUndoCommand (CQUndoCommandSc a) #

data CQUndoCommandSc a #

qCastList_QUndoCommand :: QqCastList_QUndoCommand a r => a -> r #

withQUndoCommandResult :: IO (Ptr (TQUndoCommand a)) -> IO (QUndoCommand a) #

type QStyleFactory a = Object (CQStyleFactory a) #

type TQStyleFactory a = CQStyleFactory a #

data CQStyleFactory a #

qCast_QStyleFactory :: Object a -> IO (QStyleFactory ()) #

type QStyleFactorySc a = QStyleFactory (CQStyleFactorySc a) #

type TQStyleFactorySc a = TQStyleFactory (CQStyleFactorySc a) #

data CQStyleFactorySc a #

qCastList_QStyleFactory :: QqCastList_QStyleFactory a r => a -> r #

withQStyleFactoryResult :: IO (Ptr (TQStyleFactory a)) -> IO (QStyleFactory a) #

type QToolTip a = Object (CQToolTip a) #

type TQToolTip a = CQToolTip a #

data CQToolTip a #

qCast_QToolTip :: Object a -> IO (QToolTip ()) #

type QToolTipSc a = QToolTip (CQToolTipSc a) #

type TQToolTipSc a = TQToolTip (CQToolTipSc a) #

data CQToolTipSc a #

qCastList_QToolTip :: QqCastList_QToolTip a r => a -> r #

withQToolTipResult :: IO (Ptr (TQToolTip a)) -> IO (QToolTip a) #

type QFileIconProvider a = Object (CQFileIconProvider a) #

type TQFileIconProvider a = CQFileIconProvider a #

data CQFileIconProvider a #

qCast_QFileIconProvider :: Object a -> IO (QFileIconProvider ()) #

type QFileIconProviderSc a = QFileIconProvider (CQFileIconProviderSc a) #

type TQFileIconProviderSc a = TQFileIconProvider (CQFileIconProviderSc a) #

data CQFileIconProviderSc a #

qCastList_QFileIconProvider :: QqCastList_QFileIconProvider a r => a -> r #

withQFileIconProviderResult :: IO (Ptr (TQFileIconProvider a)) -> IO (QFileIconProvider a) #

type QTableWidgetSelectionRange a = Object (CQTableWidgetSelectionRange a) #

type TQTableWidgetSelectionRange a = CQTableWidgetSelectionRange a #

data CQTableWidgetSelectionRange a #

qCast_QTableWidgetSelectionRange :: Object a -> IO (QTableWidgetSelectionRange ()) #

type QTableWidgetSelectionRangeSc a = QTableWidgetSelectionRange (CQTableWidgetSelectionRangeSc a) #

type TQTableWidgetSelectionRangeSc a = TQTableWidgetSelectionRange (CQTableWidgetSelectionRangeSc a) #

data CQTableWidgetSelectionRangeSc a #

qCastList_QTableWidgetSelectionRange :: QqCastList_QTableWidgetSelectionRange a r => a -> r #

withQTableWidgetSelectionRangeResult :: IO (Ptr (TQTableWidgetSelectionRange a)) -> IO (QTableWidgetSelectionRange a) #

withQListQTableWidgetSelectionRangeResult :: IO (Ptr (TQListQTableWidgetSelectionRange ())) -> IO [QTableWidgetSelectionRange ()] #

qTableWidgetSelectionRangeListFromPtrList :: [Ptr (TQTableWidgetSelectionRange a)] -> IO [QTableWidgetSelectionRange a] #

type QListQTableWidgetSelectionRange a = Object (CQListQTableWidgetSelectionRange a) #

type TQListQTableWidgetSelectionRange a = CQListQTableWidgetSelectionRange a #

data CQListQTableWidgetSelectionRange a #

type QFileSystemModel a = QAbstractItemModel (CQFileSystemModel a) #

type TQFileSystemModel a = TQAbstractItemModel (CQFileSystemModel a) #

data CQFileSystemModel a #

qCast_QFileSystemModel :: Object a -> IO (QFileSystemModel ()) #

type QFileSystemModelSc a = QFileSystemModel (CQFileSystemModelSc a) #

type TQFileSystemModelSc a = TQFileSystemModel (CQFileSystemModelSc a) #

data CQFileSystemModelSc a #

qCastList_QFileSystemModel :: QqCastList_QFileSystemModel a r => a -> r #

withQFileSystemModelResult :: IO (Ptr (TQFileSystemModel a)) -> IO (QFileSystemModel a) #

qFileSystemModelFromPtr :: Ptr (TQFileSystemModel a) -> IO (QFileSystemModel a) #

qFileSystemModelAddFinalizer :: QFileSystemModel a -> IO () #

type QGestureEvent a = QEvent (CQGestureEvent a) #

type TQGestureEvent a = TQEvent (CQGestureEvent a) #

data CQGestureEvent a #

qCast_QGestureEvent :: Object a -> IO (QGestureEvent ()) #

type QGestureEventSc a = QGestureEvent (CQGestureEventSc a) #

type TQGestureEventSc a = TQGestureEvent (CQGestureEventSc a) #

data CQGestureEventSc a #

qCastList_QGestureEvent :: QqCastList_QGestureEvent a r => a -> r #

withQGestureEventResult :: IO (Ptr (TQGestureEvent a)) -> IO (QGestureEvent a) #

type QMouseEventTransition a = QEventTransition (CQMouseEventTransition a) #

type TQMouseEventTransition a = TQEventTransition (CQMouseEventTransition a) #

data CQMouseEventTransition a #

qCast_QMouseEventTransition :: Object a -> IO (QMouseEventTransition ()) #

type QMouseEventTransitionSc a = QMouseEventTransition (CQMouseEventTransitionSc a) #

type TQMouseEventTransitionSc a = TQMouseEventTransition (CQMouseEventTransitionSc a) #

data CQMouseEventTransitionSc a #

qCastList_QMouseEventTransition :: QqCastList_QMouseEventTransition a r => a -> r #

withQMouseEventTransitionResult :: IO (Ptr (TQMouseEventTransition a)) -> IO (QMouseEventTransition a) #

qMouseEventTransitionFromPtr :: Ptr (TQMouseEventTransition a) -> IO (QMouseEventTransition a) #

qMouseEventTransitionAddFinalizer :: QMouseEventTransition a -> IO () #

type QKeyEventTransition a = QEventTransition (CQKeyEventTransition a) #

type TQKeyEventTransition a = TQEventTransition (CQKeyEventTransition a) #

data CQKeyEventTransition a #

qCast_QKeyEventTransition :: Object a -> IO (QKeyEventTransition ()) #

type QKeyEventTransitionSc a = QKeyEventTransition (CQKeyEventTransitionSc a) #

type TQKeyEventTransitionSc a = TQKeyEventTransition (CQKeyEventTransitionSc a) #

data CQKeyEventTransitionSc a #

qCastList_QKeyEventTransition :: QqCastList_QKeyEventTransition a r => a -> r #

withQKeyEventTransitionResult :: IO (Ptr (TQKeyEventTransition a)) -> IO (QKeyEventTransition a) #

qKeyEventTransitionFromPtr :: Ptr (TQKeyEventTransition a) -> IO (QKeyEventTransition a) #

qKeyEventTransitionAddFinalizer :: QKeyEventTransition a -> IO () #

type QGraphicsItemAnimation a = QObject (CQGraphicsItemAnimation a) #

type TQGraphicsItemAnimation a = TQObject (CQGraphicsItemAnimation a) #

data CQGraphicsItemAnimation a #

qCast_QGraphicsItemAnimation :: Object a -> IO (QGraphicsItemAnimation ()) #

type QGraphicsItemAnimationSc a = QGraphicsItemAnimation (CQGraphicsItemAnimationSc a) #

type TQGraphicsItemAnimationSc a = TQGraphicsItemAnimation (CQGraphicsItemAnimationSc a) #

data CQGraphicsItemAnimationSc a #

qCastList_QGraphicsItemAnimation :: QqCastList_QGraphicsItemAnimation a r => a -> r #

withQGraphicsItemAnimationResult :: IO (Ptr (TQGraphicsItemAnimation a)) -> IO (QGraphicsItemAnimation a) #

qGraphicsItemAnimationFromPtr :: Ptr (TQGraphicsItemAnimation a) -> IO (QGraphicsItemAnimation a) #

qGraphicsItemAnimationAddFinalizer :: QGraphicsItemAnimation a -> IO () #

type QDataWidgetMapper a = QObject (CQDataWidgetMapper a) #

type TQDataWidgetMapper a = TQObject (CQDataWidgetMapper a) #

data CQDataWidgetMapper a #

qCast_QDataWidgetMapper :: Object a -> IO (QDataWidgetMapper ()) #

type QDataWidgetMapperSc a = QDataWidgetMapper (CQDataWidgetMapperSc a) #

type TQDataWidgetMapperSc a = TQDataWidgetMapper (CQDataWidgetMapperSc a) #

data CQDataWidgetMapperSc a #

qCastList_QDataWidgetMapper :: QqCastList_QDataWidgetMapper a r => a -> r #

withQDataWidgetMapperResult :: IO (Ptr (TQDataWidgetMapper a)) -> IO (QDataWidgetMapper a) #

qDataWidgetMapperFromPtr :: Ptr (TQDataWidgetMapper a) -> IO (QDataWidgetMapper a) #

qDataWidgetMapperAddFinalizer :: QDataWidgetMapper a -> IO () #

type QUndoStack a = QObject (CQUndoStack a) #

type TQUndoStack a = TQObject (CQUndoStack a) #

data CQUndoStack a #

qCast_QUndoStack :: Object a -> IO (QUndoStack ()) #

type QUndoStackSc a = QUndoStack (CQUndoStackSc a) #

type TQUndoStackSc a = TQUndoStack (CQUndoStackSc a) #

data CQUndoStackSc a #

qCastList_QUndoStack :: QqCastList_QUndoStack a r => a -> r #

withQUndoStackResult :: IO (Ptr (TQUndoStack a)) -> IO (QUndoStack a) #

qUndoStackFromPtr :: Ptr (TQUndoStack a) -> IO (QUndoStack a) #

qUndoStackAddFinalizer :: QUndoStack a -> IO () #

withQListQUndoStackResult :: IO (Ptr (TQListQUndoStack ())) -> IO [QUndoStack ()] #

qUndoStackListFromPtrList :: [Ptr (TQUndoStack a)] -> IO [QUndoStack a] #

type QListQUndoStack a = Object (CQListQUndoStack a) #

type TQListQUndoStack a = CQListQUndoStack a #

data CQListQUndoStack a #

type QButtonGroup a = QObject (CQButtonGroup a) #

type TQButtonGroup a = TQObject (CQButtonGroup a) #

data CQButtonGroup a #

qCast_QButtonGroup :: Object a -> IO (QButtonGroup ()) #

type QButtonGroupSc a = QButtonGroup (CQButtonGroupSc a) #

type TQButtonGroupSc a = TQButtonGroup (CQButtonGroupSc a) #

data CQButtonGroupSc a #

qCastList_QButtonGroup :: QqCastList_QButtonGroup a r => a -> r #

withQButtonGroupResult :: IO (Ptr (TQButtonGroup a)) -> IO (QButtonGroup a) #

qButtonGroupFromPtr :: Ptr (TQButtonGroup a) -> IO (QButtonGroup a) #

qButtonGroupAddFinalizer :: QButtonGroup a -> IO () #

type QSystemTrayIcon a = QObject (CQSystemTrayIcon a) #

type TQSystemTrayIcon a = TQObject (CQSystemTrayIcon a) #

data CQSystemTrayIcon a #

qCast_QSystemTrayIcon :: Object a -> IO (QSystemTrayIcon ()) #

type QSystemTrayIconSc a = QSystemTrayIcon (CQSystemTrayIconSc a) #

type TQSystemTrayIconSc a = TQSystemTrayIcon (CQSystemTrayIconSc a) #

data CQSystemTrayIconSc a #

qCastList_QSystemTrayIcon :: QqCastList_QSystemTrayIcon a r => a -> r #

withQSystemTrayIconResult :: IO (Ptr (TQSystemTrayIcon a)) -> IO (QSystemTrayIcon a) #

qSystemTrayIconFromPtr :: Ptr (TQSystemTrayIcon a) -> IO (QSystemTrayIcon a) #

qSystemTrayIconAddFinalizer :: QSystemTrayIcon a -> IO () #

type QActionGroup a = QObject (CQActionGroup a) #

type TQActionGroup a = TQObject (CQActionGroup a) #

data CQActionGroup a #

qCast_QActionGroup :: Object a -> IO (QActionGroup ()) #

type QActionGroupSc a = QActionGroup (CQActionGroupSc a) #

type TQActionGroupSc a = TQActionGroup (CQActionGroupSc a) #

data CQActionGroupSc a #

qCastList_QActionGroup :: QqCastList_QActionGroup a r => a -> r #

withQActionGroupResult :: IO (Ptr (TQActionGroup a)) -> IO (QActionGroup a) #

qActionGroupFromPtr :: Ptr (TQActionGroup a) -> IO (QActionGroup a) #

qActionGroupAddFinalizer :: QActionGroup a -> IO () #

type QGraphicsScene a = QObject (CQGraphicsScene a) #

type TQGraphicsScene a = TQObject (CQGraphicsScene a) #

data CQGraphicsScene a #

qCast_QGraphicsScene :: Object a -> IO (QGraphicsScene ()) #

type QGraphicsSceneSc a = QGraphicsScene (CQGraphicsSceneSc a) #

type TQGraphicsSceneSc a = TQGraphicsScene (CQGraphicsSceneSc a) #

data CQGraphicsSceneSc a #

qCastList_QGraphicsScene :: QqCastList_QGraphicsScene a r => a -> r #

withQGraphicsSceneResult :: IO (Ptr (TQGraphicsScene a)) -> IO (QGraphicsScene a) #

qGraphicsSceneFromPtr :: Ptr (TQGraphicsScene a) -> IO (QGraphicsScene a) #

qGraphicsSceneAddFinalizer :: QGraphicsScene a -> IO () #

type QUndoGroup a = QObject (CQUndoGroup a) #

type TQUndoGroup a = TQObject (CQUndoGroup a) #

data CQUndoGroup a #

qCast_QUndoGroup :: Object a -> IO (QUndoGroup ()) #

type QUndoGroupSc a = QUndoGroup (CQUndoGroupSc a) #

type TQUndoGroupSc a = TQUndoGroup (CQUndoGroupSc a) #

data CQUndoGroupSc a #

qCastList_QUndoGroup :: QqCastList_QUndoGroup a r => a -> r #

withQUndoGroupResult :: IO (Ptr (TQUndoGroup a)) -> IO (QUndoGroup a) #

qUndoGroupFromPtr :: Ptr (TQUndoGroup a) -> IO (QUndoGroup a) #

qUndoGroupAddFinalizer :: QUndoGroup a -> IO () #

type QStylePlugin a = QObject (CQStylePlugin a) #

type TQStylePlugin a = TQObject (CQStylePlugin a) #

data CQStylePlugin a #

qCast_QStylePlugin :: Object a -> IO (QStylePlugin ()) #

type QStylePluginSc a = QStylePlugin (CQStylePluginSc a) #

type TQStylePluginSc a = TQStylePlugin (CQStylePluginSc a) #

data CQStylePluginSc a #

qCastList_QStylePlugin :: QqCastList_QStylePlugin a r => a -> r #

withQStylePluginResult :: IO (Ptr (TQStylePlugin a)) -> IO (QStylePlugin a) #

qStylePluginFromPtr :: Ptr (TQStylePlugin a) -> IO (QStylePlugin a) #

qStylePluginAddFinalizer :: QStylePlugin a -> IO () #

type QCompleter a = QObject (CQCompleter a) #

type TQCompleter a = TQObject (CQCompleter a) #

data CQCompleter a #

qCast_QCompleter :: Object a -> IO (QCompleter ()) #

type QCompleterSc a = QCompleter (CQCompleterSc a) #

type TQCompleterSc a = TQCompleter (CQCompleterSc a) #

data CQCompleterSc a #

qCastList_QCompleter :: QqCastList_QCompleter a r => a -> r #

withQCompleterResult :: IO (Ptr (TQCompleter a)) -> IO (QCompleter a) #

qCompleterFromPtr :: Ptr (TQCompleter a) -> IO (QCompleter a) #

qCompleterAddFinalizer :: QCompleter a -> IO () #

type QScroller a = QObject (CQScroller a) #

type TQScroller a = TQObject (CQScroller a) #

data CQScroller a #

qCast_QScroller :: Object a -> IO (QScroller ()) #

type QScrollerSc a = QScroller (CQScrollerSc a) #

type TQScrollerSc a = TQScroller (CQScrollerSc a) #

data CQScrollerSc a #

qCastList_QScroller :: QqCastList_QScroller a r => a -> r #

withQScrollerResult :: IO (Ptr (TQScroller a)) -> IO (QScroller a) #

qScrollerFromPtr :: Ptr (TQScroller a) -> IO (QScroller a) #

withQListQScrollerResult :: IO (Ptr (TQListQScroller ())) -> IO [QScroller ()] #

qScrollerListFromPtrList :: [Ptr (TQScroller a)] -> IO [QScroller a] #

type QListQScroller a = Object (CQListQScroller a) #

type TQListQScroller a = CQListQScroller a #

data CQListQScroller a #

type QGraphicsAnchor a = QObject (CQGraphicsAnchor a) #

type TQGraphicsAnchor a = TQObject (CQGraphicsAnchor a) #

data CQGraphicsAnchor a #

qCast_QGraphicsAnchor :: Object a -> IO (QGraphicsAnchor ()) #

type QGraphicsAnchorSc a = QGraphicsAnchor (CQGraphicsAnchorSc a) #

type TQGraphicsAnchorSc a = TQGraphicsAnchor (CQGraphicsAnchorSc a) #

data CQGraphicsAnchorSc a #

qCastList_QGraphicsAnchor :: QqCastList_QGraphicsAnchor a r => a -> r #

withQGraphicsAnchorResult :: IO (Ptr (TQGraphicsAnchor a)) -> IO (QGraphicsAnchor a) #

qGraphicsAnchorFromPtr :: Ptr (TQGraphicsAnchor a) -> IO (QGraphicsAnchor a) #

qGraphicsAnchorAddFinalizer :: QGraphicsAnchor a -> IO () #

type QShortcut a = QObject (CQShortcut a) #

type TQShortcut a = TQObject (CQShortcut a) #

data CQShortcut a #

qCast_QShortcut :: Object a -> IO (QShortcut ()) #

type QShortcutSc a = QShortcut (CQShortcutSc a) #

type TQShortcutSc a = TQShortcut (CQShortcutSc a) #

data CQShortcutSc a #

qCastList_QShortcut :: QqCastList_QShortcut a r => a -> r #

withQShortcutResult :: IO (Ptr (TQShortcut a)) -> IO (QShortcut a) #

qShortcutFromPtr :: Ptr (TQShortcut a) -> IO (QShortcut a) #

qShortcutAddFinalizer :: QShortcut a -> IO () #

type QCalendarWidget a = QWidget (CQCalendarWidget a) #

type TQCalendarWidget a = TQWidget (CQCalendarWidget a) #

data CQCalendarWidget a #

qCast_QCalendarWidget :: Object a -> IO (QCalendarWidget ()) #

type QCalendarWidgetSc a = QCalendarWidget (CQCalendarWidgetSc a) #

type TQCalendarWidgetSc a = TQCalendarWidget (CQCalendarWidgetSc a) #

data CQCalendarWidgetSc a #

qCastList_QCalendarWidget :: QqCastList_QCalendarWidget a r => a -> r #

withQCalendarWidgetResult :: IO (Ptr (TQCalendarWidget a)) -> IO (QCalendarWidget a) #

qCalendarWidgetFromPtr :: Ptr (TQCalendarWidget a) -> IO (QCalendarWidget a) #

qCalendarWidgetAddFinalizer :: QCalendarWidget a -> IO () #

type QSplitterHandle a = QWidget (CQSplitterHandle a) #

type TQSplitterHandle a = TQWidget (CQSplitterHandle a) #

data CQSplitterHandle a #

qCast_QSplitterHandle :: Object a -> IO (QSplitterHandle ()) #

type QSplitterHandleSc a = QSplitterHandle (CQSplitterHandleSc a) #

type TQSplitterHandleSc a = TQSplitterHandle (CQSplitterHandleSc a) #

data CQSplitterHandleSc a #

qCastList_QSplitterHandle :: QqCastList_QSplitterHandle a r => a -> r #

withQSplitterHandleResult :: IO (Ptr (TQSplitterHandle a)) -> IO (QSplitterHandle a) #

qSplitterHandleFromPtr :: Ptr (TQSplitterHandle a) -> IO (QSplitterHandle a) #

qSplitterHandleAddFinalizer :: QSplitterHandle a -> IO () #

type QTabBar a = QWidget (CQTabBar a) #

type TQTabBar a = TQWidget (CQTabBar a) #

data CQTabBar a #

qCast_QTabBar :: Object a -> IO (QTabBar ()) #

type QTabBarSc a = QTabBar (CQTabBarSc a) #

type TQTabBarSc a = TQTabBar (CQTabBarSc a) #

data CQTabBarSc a #

qCastList_QTabBar :: QqCastList_QTabBar a r => a -> r #

withQTabBarResult :: IO (Ptr (TQTabBar a)) -> IO (QTabBar a) #

qTabBarFromPtr :: Ptr (TQTabBar a) -> IO (QTabBar a) #

qTabBarAddFinalizer :: QTabBar a -> IO () #

type QProgressBar a = QWidget (CQProgressBar a) #

type TQProgressBar a = TQWidget (CQProgressBar a) #

data CQProgressBar a #

qCast_QProgressBar :: Object a -> IO (QProgressBar ()) #

type QProgressBarSc a = QProgressBar (CQProgressBarSc a) #

type TQProgressBarSc a = TQProgressBar (CQProgressBarSc a) #

data CQProgressBarSc a #

qCastList_QProgressBar :: QqCastList_QProgressBar a r => a -> r #

withQProgressBarResult :: IO (Ptr (TQProgressBar a)) -> IO (QProgressBar a) #

qProgressBarFromPtr :: Ptr (TQProgressBar a) -> IO (QProgressBar a) #

qProgressBarAddFinalizer :: QProgressBar a -> IO () #

type QTabWidget a = QWidget (CQTabWidget a) #

type TQTabWidget a = TQWidget (CQTabWidget a) #

data CQTabWidget a #

qCast_QTabWidget :: Object a -> IO (QTabWidget ()) #

type QTabWidgetSc a = QTabWidget (CQTabWidgetSc a) #

type TQTabWidgetSc a = TQTabWidget (CQTabWidgetSc a) #

data CQTabWidgetSc a #

qCastList_QTabWidget :: QqCastList_QTabWidget a r => a -> r #

withQTabWidgetResult :: IO (Ptr (TQTabWidget a)) -> IO (QTabWidget a) #

qTabWidgetFromPtr :: Ptr (TQTabWidget a) -> IO (QTabWidget a) #

qTabWidgetAddFinalizer :: QTabWidget a -> IO () #

type QStatusBar a = QWidget (CQStatusBar a) #

type TQStatusBar a = TQWidget (CQStatusBar a) #

data CQStatusBar a #

qCast_QStatusBar :: Object a -> IO (QStatusBar ()) #

type QStatusBarSc a = QStatusBar (CQStatusBarSc a) #

type TQStatusBarSc a = TQStatusBar (CQStatusBarSc a) #

data CQStatusBarSc a #

qCastList_QStatusBar :: QqCastList_QStatusBar a r => a -> r #

withQStatusBarResult :: IO (Ptr (TQStatusBar a)) -> IO (QStatusBar a) #

qStatusBarFromPtr :: Ptr (TQStatusBar a) -> IO (QStatusBar a) #

qStatusBarAddFinalizer :: QStatusBar a -> IO () #

type QWizardPage a = QWidget (CQWizardPage a) #

type TQWizardPage a = TQWidget (CQWizardPage a) #

data CQWizardPage a #

qCast_QWizardPage :: Object a -> IO (QWizardPage ()) #

type QWizardPageSc a = QWizardPage (CQWizardPageSc a) #

type TQWizardPageSc a = TQWizardPage (CQWizardPageSc a) #

data CQWizardPageSc a #

qCastList_QWizardPage :: QqCastList_QWizardPage a r => a -> r #

withQWizardPageResult :: IO (Ptr (TQWizardPage a)) -> IO (QWizardPage a) #

qWizardPageFromPtr :: Ptr (TQWizardPage a) -> IO (QWizardPage a) #

qWizardPageAddFinalizer :: QWizardPage a -> IO () #

type QMainWindow a = QWidget (CQMainWindow a) #

type TQMainWindow a = TQWidget (CQMainWindow a) #

data CQMainWindow a #

qCast_QMainWindow :: Object a -> IO (QMainWindow ()) #

type QMainWindowSc a = QMainWindow (CQMainWindowSc a) #

type TQMainWindowSc a = TQMainWindow (CQMainWindowSc a) #

data CQMainWindowSc a #

qCastList_QMainWindow :: QqCastList_QMainWindow a r => a -> r #

withQMainWindowResult :: IO (Ptr (TQMainWindow a)) -> IO (QMainWindow a) #

qMainWindowFromPtr :: Ptr (TQMainWindow a) -> IO (QMainWindow a) #

qMainWindowAddFinalizer :: QMainWindow a -> IO () #

type QToolBar a = QWidget (CQToolBar a) #

type TQToolBar a = TQWidget (CQToolBar a) #

data CQToolBar a #

qCast_QToolBar :: Object a -> IO (QToolBar ()) #

type QToolBarSc a = QToolBar (CQToolBarSc a) #

type TQToolBarSc a = TQToolBar (CQToolBarSc a) #

data CQToolBarSc a #

qCastList_QToolBar :: QqCastList_QToolBar a r => a -> r #

withQToolBarResult :: IO (Ptr (TQToolBar a)) -> IO (QToolBar a) #

qToolBarFromPtr :: Ptr (TQToolBar a) -> IO (QToolBar a) #

qToolBarAddFinalizer :: QToolBar a -> IO () #

type QMdiSubWindow a = QWidget (CQMdiSubWindow a) #

type TQMdiSubWindow a = TQWidget (CQMdiSubWindow a) #

data CQMdiSubWindow a #

qCast_QMdiSubWindow :: Object a -> IO (QMdiSubWindow ()) #

type QMdiSubWindowSc a = QMdiSubWindow (CQMdiSubWindowSc a) #

type TQMdiSubWindowSc a = TQMdiSubWindow (CQMdiSubWindowSc a) #

data CQMdiSubWindowSc a #

qCastList_QMdiSubWindow :: QqCastList_QMdiSubWindow a r => a -> r #

withQMdiSubWindowResult :: IO (Ptr (TQMdiSubWindow a)) -> IO (QMdiSubWindow a) #

qMdiSubWindowFromPtr :: Ptr (TQMdiSubWindow a) -> IO (QMdiSubWindow a) #

qMdiSubWindowAddFinalizer :: QMdiSubWindow a -> IO () #

withQListQMdiSubWindowResult :: IO (Ptr (TQListQMdiSubWindow ())) -> IO [QMdiSubWindow ()] #

qMdiSubWindowListFromPtrList :: [Ptr (TQMdiSubWindow a)] -> IO [QMdiSubWindow a] #

type QListQMdiSubWindow a = Object (CQListQMdiSubWindow a) #

type TQListQMdiSubWindow a = CQListQMdiSubWindow a #

data CQListQMdiSubWindow a #

type QFocusFrame a = QWidget (CQFocusFrame a) #

type TQFocusFrame a = TQWidget (CQFocusFrame a) #

data CQFocusFrame a #

qCast_QFocusFrame :: Object a -> IO (QFocusFrame ()) #

type QFocusFrameSc a = QFocusFrame (CQFocusFrameSc a) #

type TQFocusFrameSc a = TQFocusFrame (CQFocusFrameSc a) #

data CQFocusFrameSc a #

qCastList_QFocusFrame :: QqCastList_QFocusFrame a r => a -> r #

withQFocusFrameResult :: IO (Ptr (TQFocusFrame a)) -> IO (QFocusFrame a) #

qFocusFrameFromPtr :: Ptr (TQFocusFrame a) -> IO (QFocusFrame a) #

qFocusFrameAddFinalizer :: QFocusFrame a -> IO () #

type QRubberBand a = QWidget (CQRubberBand a) #

type TQRubberBand a = TQWidget (CQRubberBand a) #

data CQRubberBand a #

qCast_QRubberBand :: Object a -> IO (QRubberBand ()) #

type QRubberBandSc a = QRubberBand (CQRubberBandSc a) #

type TQRubberBandSc a = TQRubberBand (CQRubberBandSc a) #

data CQRubberBandSc a #

qCastList_QRubberBand :: QqCastList_QRubberBand a r => a -> r #

withQRubberBandResult :: IO (Ptr (TQRubberBand a)) -> IO (QRubberBand a) #

qRubberBandFromPtr :: Ptr (TQRubberBand a) -> IO (QRubberBand a) #

qRubberBandAddFinalizer :: QRubberBand a -> IO () #

type QGroupBox a = QWidget (CQGroupBox a) #

type TQGroupBox a = TQWidget (CQGroupBox a) #

data CQGroupBox a #

qCast_QGroupBox :: Object a -> IO (QGroupBox ()) #

type QGroupBoxSc a = QGroupBox (CQGroupBoxSc a) #

type TQGroupBoxSc a = TQGroupBox (CQGroupBoxSc a) #

data CQGroupBoxSc a #

qCastList_QGroupBox :: QqCastList_QGroupBox a r => a -> r #

withQGroupBoxResult :: IO (Ptr (TQGroupBox a)) -> IO (QGroupBox a) #

qGroupBoxFromPtr :: Ptr (TQGroupBox a) -> IO (QGroupBox a) #

qGroupBoxAddFinalizer :: QGroupBox a -> IO () #

type QDialogButtonBox a = QWidget (CQDialogButtonBox a) #

type TQDialogButtonBox a = TQWidget (CQDialogButtonBox a) #

data CQDialogButtonBox a #

qCast_QDialogButtonBox :: Object a -> IO (QDialogButtonBox ()) #

type QDialogButtonBoxSc a = QDialogButtonBox (CQDialogButtonBoxSc a) #

type TQDialogButtonBoxSc a = TQDialogButtonBox (CQDialogButtonBoxSc a) #

data CQDialogButtonBoxSc a #

qCastList_QDialogButtonBox :: QqCastList_QDialogButtonBox a r => a -> r #

withQDialogButtonBoxResult :: IO (Ptr (TQDialogButtonBox a)) -> IO (QDialogButtonBox a) #

qDialogButtonBoxFromPtr :: Ptr (TQDialogButtonBox a) -> IO (QDialogButtonBox a) #

qDialogButtonBoxAddFinalizer :: QDialogButtonBox a -> IO () #

type QSizeGrip a = QWidget (CQSizeGrip a) #

type TQSizeGrip a = TQWidget (CQSizeGrip a) #

data CQSizeGrip a #

qCast_QSizeGrip :: Object a -> IO (QSizeGrip ()) #

type QSizeGripSc a = QSizeGrip (CQSizeGripSc a) #

type TQSizeGripSc a = TQSizeGrip (CQSizeGripSc a) #

data CQSizeGripSc a #

qCastList_QSizeGrip :: QqCastList_QSizeGrip a r => a -> r #

withQSizeGripResult :: IO (Ptr (TQSizeGrip a)) -> IO (QSizeGrip a) #

qSizeGripFromPtr :: Ptr (TQSizeGrip a) -> IO (QSizeGrip a) #

qSizeGripAddFinalizer :: QSizeGrip a -> IO () #

type QMenuBar a = QWidget (CQMenuBar a) #

type TQMenuBar a = TQWidget (CQMenuBar a) #

data CQMenuBar a #

qCast_QMenuBar :: Object a -> IO (QMenuBar ()) #

type QMenuBarSc a = QMenuBar (CQMenuBarSc a) #

type TQMenuBarSc a = TQMenuBar (CQMenuBarSc a) #

data CQMenuBarSc a #

qCastList_QMenuBar :: QqCastList_QMenuBar a r => a -> r #

withQMenuBarResult :: IO (Ptr (TQMenuBar a)) -> IO (QMenuBar a) #

qMenuBarFromPtr :: Ptr (TQMenuBar a) -> IO (QMenuBar a) #

qMenuBarAddFinalizer :: QMenuBar a -> IO () #

type QMenu a = QWidget (CQMenu a) #

type TQMenu a = TQWidget (CQMenu a) #

data CQMenu a #

qCast_QMenu :: Object a -> IO (QMenu ()) #

type QMenuSc a = QMenu (CQMenuSc a) #

type TQMenuSc a = TQMenu (CQMenuSc a) #

data CQMenuSc a #

qCastList_QMenu :: QqCastList_QMenu a r => a -> r #

withQMenuResult :: IO (Ptr (TQMenu a)) -> IO (QMenu a) #

qMenuFromPtr :: Ptr (TQMenu a) -> IO (QMenu a) #

qMenuAddFinalizer :: QMenu a -> IO () #

type QSplashScreen a = QWidget (CQSplashScreen a) #

type TQSplashScreen a = TQWidget (CQSplashScreen a) #

data CQSplashScreen a #

qCast_QSplashScreen :: Object a -> IO (QSplashScreen ()) #

type QSplashScreenSc a = QSplashScreen (CQSplashScreenSc a) #

type TQSplashScreenSc a = TQSplashScreen (CQSplashScreenSc a) #

data CQSplashScreenSc a #

qCastList_QSplashScreen :: QqCastList_QSplashScreen a r => a -> r #

withQSplashScreenResult :: IO (Ptr (TQSplashScreen a)) -> IO (QSplashScreen a) #

qSplashScreenFromPtr :: Ptr (TQSplashScreen a) -> IO (QSplashScreen a) #

qSplashScreenAddFinalizer :: QSplashScreen a -> IO () #

type QDesktopWidget a = QWidget (CQDesktopWidget a) #

type TQDesktopWidget a = TQWidget (CQDesktopWidget a) #

data CQDesktopWidget a #

qCast_QDesktopWidget :: Object a -> IO (QDesktopWidget ()) #

type QDesktopWidgetSc a = QDesktopWidget (CQDesktopWidgetSc a) #

type TQDesktopWidgetSc a = TQDesktopWidget (CQDesktopWidgetSc a) #

data CQDesktopWidgetSc a #

qCastList_QDesktopWidget :: QqCastList_QDesktopWidget a r => a -> r #

withQDesktopWidgetResult :: IO (Ptr (TQDesktopWidget a)) -> IO (QDesktopWidget a) #

qDesktopWidgetFromPtr :: Ptr (TQDesktopWidget a) -> IO (QDesktopWidget a) #

qDesktopWidgetAddFinalizer :: QDesktopWidget a -> IO () #

type QLineEdit a = QWidget (CQLineEdit a) #

type TQLineEdit a = TQWidget (CQLineEdit a) #

data CQLineEdit a #

qCast_QLineEdit :: Object a -> IO (QLineEdit ()) #

type QLineEditSc a = QLineEdit (CQLineEditSc a) #

type TQLineEditSc a = TQLineEdit (CQLineEditSc a) #

data CQLineEditSc a #

qCastList_QLineEdit :: QqCastList_QLineEdit a r => a -> r #

withQLineEditResult :: IO (Ptr (TQLineEdit a)) -> IO (QLineEdit a) #

qLineEditFromPtr :: Ptr (TQLineEdit a) -> IO (QLineEdit a) #

qLineEditAddFinalizer :: QLineEdit a -> IO () #

type QDockWidget a = QWidget (CQDockWidget a) #

type TQDockWidget a = TQWidget (CQDockWidget a) #

data CQDockWidget a #

qCast_QDockWidget :: Object a -> IO (QDockWidget ()) #

type QDockWidgetSc a = QDockWidget (CQDockWidgetSc a) #

type TQDockWidgetSc a = TQDockWidget (CQDockWidgetSc a) #

data CQDockWidgetSc a #

qCastList_QDockWidget :: QqCastList_QDockWidget a r => a -> r #

withQDockWidgetResult :: IO (Ptr (TQDockWidget a)) -> IO (QDockWidget a) #

qDockWidgetFromPtr :: Ptr (TQDockWidget a) -> IO (QDockWidget a) #

qDockWidgetAddFinalizer :: QDockWidget a -> IO () #

withQListQDockWidgetResult :: IO (Ptr (TQListQDockWidget ())) -> IO [QDockWidget ()] #

qDockWidgetListFromPtrList :: [Ptr (TQDockWidget a)] -> IO [QDockWidget a] #

type QListQDockWidget a = Object (CQListQDockWidget a) #

type TQListQDockWidget a = CQListQDockWidget a #

data CQListQDockWidget a #

type QPlainTextDocumentLayout a = QAbstractTextDocumentLayout (CQPlainTextDocumentLayout a) #

type TQPlainTextDocumentLayout a = TQAbstractTextDocumentLayout (CQPlainTextDocumentLayout a) #

data CQPlainTextDocumentLayout a #

qCast_QPlainTextDocumentLayout :: Object a -> IO (QPlainTextDocumentLayout ()) #

type QPlainTextDocumentLayoutSc a = QPlainTextDocumentLayout (CQPlainTextDocumentLayoutSc a) #

type TQPlainTextDocumentLayoutSc a = TQPlainTextDocumentLayout (CQPlainTextDocumentLayoutSc a) #

data CQPlainTextDocumentLayoutSc a #

qCastList_QPlainTextDocumentLayout :: QqCastList_QPlainTextDocumentLayout a r => a -> r #

withQPlainTextDocumentLayoutResult :: IO (Ptr (TQPlainTextDocumentLayout a)) -> IO (QPlainTextDocumentLayout a) #

qPlainTextDocumentLayoutFromPtr :: Ptr (TQPlainTextDocumentLayout a) -> IO (QPlainTextDocumentLayout a) #

qPlainTextDocumentLayoutAddFinalizer :: QPlainTextDocumentLayout a -> IO () #

type QWidgetAction a = QAction (CQWidgetAction a) #

type TQWidgetAction a = TQAction (CQWidgetAction a) #

data CQWidgetAction a #

qCast_QWidgetAction :: Object a -> IO (QWidgetAction ()) #

type QWidgetActionSc a = QWidgetAction (CQWidgetActionSc a) #

type TQWidgetActionSc a = TQWidgetAction (CQWidgetActionSc a) #

data CQWidgetActionSc a #

qCastList_QWidgetAction :: QqCastList_QWidgetAction a r => a -> r #

withQWidgetActionResult :: IO (Ptr (TQWidgetAction a)) -> IO (QWidgetAction a) #

qWidgetActionFromPtr :: Ptr (TQWidgetAction a) -> IO (QWidgetAction a) #

qWidgetActionAddFinalizer :: QWidgetAction a -> IO () #

type QApplication a = QGuiApplication (CQApplication a) #

type TQApplication a = TQGuiApplication (CQApplication a) #

data CQApplication a #

qCast_QApplication :: Object a -> IO (QApplication ()) #

type QApplicationSc a = QApplication (CQApplicationSc a) #

type TQApplicationSc a = TQApplication (CQApplicationSc a) #

data CQApplicationSc a #

withQApplicationResult :: IO (Ptr (TQApplication a)) -> IO (QApplication a) #

qApplicationFromPtr :: Ptr (TQApplication a) -> IO (QApplication a) #

qApplicationAddFinalizer :: QApplication a -> IO () #

type QStylePainter a = QPainter (CQStylePainter a) #

type TQStylePainter a = TQPainter (CQStylePainter a) #

data CQStylePainter a #

qCast_QStylePainter :: Object a -> IO (QStylePainter ()) #

type QStylePainterSc a = QStylePainter (CQStylePainterSc a) #

type TQStylePainterSc a = TQStylePainter (CQStylePainterSc a) #

data CQStylePainterSc a #

qCastList_QStylePainter :: QqCastList_QStylePainter a r => a -> r #

withQStylePainterResult :: IO (Ptr (TQStylePainter a)) -> IO (QStylePainter a) #

type QToolButton a = QAbstractButton (CQToolButton a) #

type TQToolButton a = TQAbstractButton (CQToolButton a) #

data CQToolButton a #

qCast_QToolButton :: Object a -> IO (QToolButton ()) #

type QToolButtonSc a = QToolButton (CQToolButtonSc a) #

type TQToolButtonSc a = TQToolButton (CQToolButtonSc a) #

data CQToolButtonSc a #

qCastList_QToolButton :: QqCastList_QToolButton a r => a -> r #

withQToolButtonResult :: IO (Ptr (TQToolButton a)) -> IO (QToolButton a) #

qToolButtonFromPtr :: Ptr (TQToolButton a) -> IO (QToolButton a) #

qToolButtonAddFinalizer :: QToolButton a -> IO () #

type QRadioButton a = QAbstractButton (CQRadioButton a) #

type TQRadioButton a = TQAbstractButton (CQRadioButton a) #

data CQRadioButton a #

qCast_QRadioButton :: Object a -> IO (QRadioButton ()) #

type QRadioButtonSc a = QRadioButton (CQRadioButtonSc a) #

type TQRadioButtonSc a = TQRadioButton (CQRadioButtonSc a) #

data CQRadioButtonSc a #

qCastList_QRadioButton :: QqCastList_QRadioButton a r => a -> r #

withQRadioButtonResult :: IO (Ptr (TQRadioButton a)) -> IO (QRadioButton a) #

qRadioButtonFromPtr :: Ptr (TQRadioButton a) -> IO (QRadioButton a) #

qRadioButtonAddFinalizer :: QRadioButton a -> IO () #

type QCheckBox a = QAbstractButton (CQCheckBox a) #

type TQCheckBox a = TQAbstractButton (CQCheckBox a) #

data CQCheckBox a #

qCast_QCheckBox :: Object a -> IO (QCheckBox ()) #

type QCheckBoxSc a = QCheckBox (CQCheckBoxSc a) #

type TQCheckBoxSc a = TQCheckBox (CQCheckBoxSc a) #

data CQCheckBoxSc a #

qCastList_QCheckBox :: QqCastList_QCheckBox a r => a -> r #

withQCheckBoxResult :: IO (Ptr (TQCheckBox a)) -> IO (QCheckBox a) #

qCheckBoxFromPtr :: Ptr (TQCheckBox a) -> IO (QCheckBox a) #

qCheckBoxAddFinalizer :: QCheckBox a -> IO () #

type QGraphicsPathItem a = QAbstractGraphicsShapeItem (CQGraphicsPathItem a) #

type TQGraphicsPathItem a = TQAbstractGraphicsShapeItem (CQGraphicsPathItem a) #

data CQGraphicsPathItem a #

qCast_QGraphicsPathItem :: Object a -> IO (QGraphicsPathItem ()) #

type QGraphicsPathItemSc a = QGraphicsPathItem (CQGraphicsPathItemSc a) #

type TQGraphicsPathItemSc a = TQGraphicsPathItem (CQGraphicsPathItemSc a) #

data CQGraphicsPathItemSc a #

qCastList_QGraphicsPathItem :: QqCastList_QGraphicsPathItem a r => a -> r #

withQGraphicsPathItemResult :: IO (Ptr (TQGraphicsPathItem a)) -> IO (QGraphicsPathItem a) #

type QGraphicsEllipseItem a = QAbstractGraphicsShapeItem (CQGraphicsEllipseItem a) #

type TQGraphicsEllipseItem a = TQAbstractGraphicsShapeItem (CQGraphicsEllipseItem a) #

data CQGraphicsEllipseItem a #

qCast_QGraphicsEllipseItem :: Object a -> IO (QGraphicsEllipseItem ()) #

type QGraphicsEllipseItemSc a = QGraphicsEllipseItem (CQGraphicsEllipseItemSc a) #

type TQGraphicsEllipseItemSc a = TQGraphicsEllipseItem (CQGraphicsEllipseItemSc a) #

data CQGraphicsEllipseItemSc a #

qCastList_QGraphicsEllipseItem :: QqCastList_QGraphicsEllipseItem a r => a -> r #

withQGraphicsEllipseItemResult :: IO (Ptr (TQGraphicsEllipseItem a)) -> IO (QGraphicsEllipseItem a) #

type QGraphicsSimpleTextItem a = QAbstractGraphicsShapeItem (CQGraphicsSimpleTextItem a) #

type TQGraphicsSimpleTextItem a = TQAbstractGraphicsShapeItem (CQGraphicsSimpleTextItem a) #

data CQGraphicsSimpleTextItem a #

qCast_QGraphicsSimpleTextItem :: Object a -> IO (QGraphicsSimpleTextItem ()) #

type QGraphicsSimpleTextItemSc a = QGraphicsSimpleTextItem (CQGraphicsSimpleTextItemSc a) #

type TQGraphicsSimpleTextItemSc a = TQGraphicsSimpleTextItem (CQGraphicsSimpleTextItemSc a) #

data CQGraphicsSimpleTextItemSc a #

qCastList_QGraphicsSimpleTextItem :: QqCastList_QGraphicsSimpleTextItem a r => a -> r #

withQGraphicsSimpleTextItemResult :: IO (Ptr (TQGraphicsSimpleTextItem a)) -> IO (QGraphicsSimpleTextItem a) #

type QGraphicsRectItem a = QAbstractGraphicsShapeItem (CQGraphicsRectItem a) #

type TQGraphicsRectItem a = TQAbstractGraphicsShapeItem (CQGraphicsRectItem a) #

data CQGraphicsRectItem a #

qCast_QGraphicsRectItem :: Object a -> IO (QGraphicsRectItem ()) #

type QGraphicsRectItemSc a = QGraphicsRectItem (CQGraphicsRectItemSc a) #

type TQGraphicsRectItemSc a = TQGraphicsRectItem (CQGraphicsRectItemSc a) #

data CQGraphicsRectItemSc a #

qCastList_QGraphicsRectItem :: QqCastList_QGraphicsRectItem a r => a -> r #

withQGraphicsRectItemResult :: IO (Ptr (TQGraphicsRectItem a)) -> IO (QGraphicsRectItem a) #

type QGraphicsPolygonItem a = QAbstractGraphicsShapeItem (CQGraphicsPolygonItem a) #

type TQGraphicsPolygonItem a = TQAbstractGraphicsShapeItem (CQGraphicsPolygonItem a) #

data CQGraphicsPolygonItem a #

qCast_QGraphicsPolygonItem :: Object a -> IO (QGraphicsPolygonItem ()) #

type QGraphicsPolygonItemSc a = QGraphicsPolygonItem (CQGraphicsPolygonItemSc a) #

type TQGraphicsPolygonItemSc a = TQGraphicsPolygonItem (CQGraphicsPolygonItemSc a) #

data CQGraphicsPolygonItemSc a #

qCastList_QGraphicsPolygonItem :: QqCastList_QGraphicsPolygonItem a r => a -> r #

withQGraphicsPolygonItemResult :: IO (Ptr (TQGraphicsPolygonItem a)) -> IO (QGraphicsPolygonItem a) #

type QItemDelegate a = QAbstractItemDelegate (CQItemDelegate a) #

type TQItemDelegate a = TQAbstractItemDelegate (CQItemDelegate a) #

data CQItemDelegate a #

qCast_QItemDelegate :: Object a -> IO (QItemDelegate ()) #

type QItemDelegateSc a = QItemDelegate (CQItemDelegateSc a) #

type TQItemDelegateSc a = TQItemDelegate (CQItemDelegateSc a) #

data CQItemDelegateSc a #

qCastList_QItemDelegate :: QqCastList_QItemDelegate a r => a -> r #

withQItemDelegateResult :: IO (Ptr (TQItemDelegate a)) -> IO (QItemDelegate a) #

qItemDelegateFromPtr :: Ptr (TQItemDelegate a) -> IO (QItemDelegate a) #

qItemDelegateAddFinalizer :: QItemDelegate a -> IO () #

type QStyledItemDelegate a = QAbstractItemDelegate (CQStyledItemDelegate a) #

type TQStyledItemDelegate a = TQAbstractItemDelegate (CQStyledItemDelegate a) #

data CQStyledItemDelegate a #

qCast_QStyledItemDelegate :: Object a -> IO (QStyledItemDelegate ()) #

type QStyledItemDelegateSc a = QStyledItemDelegate (CQStyledItemDelegateSc a) #

type TQStyledItemDelegateSc a = TQStyledItemDelegate (CQStyledItemDelegateSc a) #

data CQStyledItemDelegateSc a #

qCastList_QStyledItemDelegate :: QqCastList_QStyledItemDelegate a r => a -> r #

withQStyledItemDelegateResult :: IO (Ptr (TQStyledItemDelegate a)) -> IO (QStyledItemDelegate a) #

qStyledItemDelegateFromPtr :: Ptr (TQStyledItemDelegate a) -> IO (QStyledItemDelegate a) #

qStyledItemDelegateAddFinalizer :: QStyledItemDelegate a -> IO () #

type QColumnView a = QAbstractItemView (CQColumnView a) #

type TQColumnView a = TQAbstractItemView (CQColumnView a) #

data CQColumnView a #

qCast_QColumnView :: Object a -> IO (QColumnView ()) #

type QColumnViewSc a = QColumnView (CQColumnViewSc a) #

type TQColumnViewSc a = TQColumnView (CQColumnViewSc a) #

data CQColumnViewSc a #

qCastList_QColumnView :: QqCastList_QColumnView a r => a -> r #

withQColumnViewResult :: IO (Ptr (TQColumnView a)) -> IO (QColumnView a) #

qColumnViewFromPtr :: Ptr (TQColumnView a) -> IO (QColumnView a) #

qColumnViewAddFinalizer :: QColumnView a -> IO () #

type QHeaderView a = QAbstractItemView (CQHeaderView a) #

type TQHeaderView a = TQAbstractItemView (CQHeaderView a) #

data CQHeaderView a #

qCast_QHeaderView :: Object a -> IO (QHeaderView ()) #

type QHeaderViewSc a = QHeaderView (CQHeaderViewSc a) #

type TQHeaderViewSc a = TQHeaderView (CQHeaderViewSc a) #

data CQHeaderViewSc a #

qCastList_QHeaderView :: QqCastList_QHeaderView a r => a -> r #

withQHeaderViewResult :: IO (Ptr (TQHeaderView a)) -> IO (QHeaderView a) #

qHeaderViewFromPtr :: Ptr (TQHeaderView a) -> IO (QHeaderView a) #

qHeaderViewAddFinalizer :: QHeaderView a -> IO () #

type QScrollArea a = QAbstractScrollArea (CQScrollArea a) #

type TQScrollArea a = TQAbstractScrollArea (CQScrollArea a) #

data CQScrollArea a #

qCast_QScrollArea :: Object a -> IO (QScrollArea ()) #

type QScrollAreaSc a = QScrollArea (CQScrollAreaSc a) #

type TQScrollAreaSc a = TQScrollArea (CQScrollAreaSc a) #

data CQScrollAreaSc a #

qCastList_QScrollArea :: QqCastList_QScrollArea a r => a -> r #

withQScrollAreaResult :: IO (Ptr (TQScrollArea a)) -> IO (QScrollArea a) #

qScrollAreaFromPtr :: Ptr (TQScrollArea a) -> IO (QScrollArea a) #

qScrollAreaAddFinalizer :: QScrollArea a -> IO () #

type QGraphicsView a = QAbstractScrollArea (CQGraphicsView a) #

type TQGraphicsView a = TQAbstractScrollArea (CQGraphicsView a) #

data CQGraphicsView a #

qCast_QGraphicsView :: Object a -> IO (QGraphicsView ()) #

type QGraphicsViewSc a = QGraphicsView (CQGraphicsViewSc a) #

type TQGraphicsViewSc a = TQGraphicsView (CQGraphicsViewSc a) #

data CQGraphicsViewSc a #

qCastList_QGraphicsView :: QqCastList_QGraphicsView a r => a -> r #

withQGraphicsViewResult :: IO (Ptr (TQGraphicsView a)) -> IO (QGraphicsView a) #

qGraphicsViewFromPtr :: Ptr (TQGraphicsView a) -> IO (QGraphicsView a) #

qGraphicsViewAddFinalizer :: QGraphicsView a -> IO () #

withQListQGraphicsViewResult :: IO (Ptr (TQListQGraphicsView ())) -> IO [QGraphicsView ()] #

qGraphicsViewListFromPtrList :: [Ptr (TQGraphicsView a)] -> IO [QGraphicsView a] #

type QListQGraphicsView a = Object (CQListQGraphicsView a) #

type TQListQGraphicsView a = CQListQGraphicsView a #

data CQListQGraphicsView a #

type QPlainTextEdit a = QAbstractScrollArea (CQPlainTextEdit a) #

type TQPlainTextEdit a = TQAbstractScrollArea (CQPlainTextEdit a) #

data CQPlainTextEdit a #

qCast_QPlainTextEdit :: Object a -> IO (QPlainTextEdit ()) #

type QPlainTextEditSc a = QPlainTextEdit (CQPlainTextEditSc a) #

type TQPlainTextEditSc a = TQPlainTextEdit (CQPlainTextEditSc a) #

data CQPlainTextEditSc a #

qCastList_QPlainTextEdit :: QqCastList_QPlainTextEdit a r => a -> r #

withQPlainTextEditResult :: IO (Ptr (TQPlainTextEdit a)) -> IO (QPlainTextEdit a) #

qPlainTextEditFromPtr :: Ptr (TQPlainTextEdit a) -> IO (QPlainTextEdit a) #

qPlainTextEditAddFinalizer :: QPlainTextEdit a -> IO () #

type QMdiArea a = QAbstractScrollArea (CQMdiArea a) #

type TQMdiArea a = TQAbstractScrollArea (CQMdiArea a) #

data CQMdiArea a #

qCast_QMdiArea :: Object a -> IO (QMdiArea ()) #

type QMdiAreaSc a = QMdiArea (CQMdiAreaSc a) #

type TQMdiAreaSc a = TQMdiArea (CQMdiAreaSc a) #

data CQMdiAreaSc a #

qCastList_QMdiArea :: QqCastList_QMdiArea a r => a -> r #

withQMdiAreaResult :: IO (Ptr (TQMdiArea a)) -> IO (QMdiArea a) #

qMdiAreaFromPtr :: Ptr (TQMdiArea a) -> IO (QMdiArea a) #

qMdiAreaAddFinalizer :: QMdiArea a -> IO () #

type QScrollBar a = QAbstractSlider (CQScrollBar a) #

type TQScrollBar a = TQAbstractSlider (CQScrollBar a) #

data CQScrollBar a #

qCast_QScrollBar :: Object a -> IO (QScrollBar ()) #

type QScrollBarSc a = QScrollBar (CQScrollBarSc a) #

type TQScrollBarSc a = TQScrollBar (CQScrollBarSc a) #

data CQScrollBarSc a #

qCastList_QScrollBar :: QqCastList_QScrollBar a r => a -> r #