Documentation

type QwtPlotItem a = Object (CQwtPlotItem a) #

type TQwtPlotItem a = CQwtPlotItem a #

data CQwtPlotItem a #

qCast_QwtPlotItem :: Object a -> IO (QwtPlotItem ()) #

type QwtPlotItemSc a = QwtPlotItem (CQwtPlotItemSc a) #

type TQwtPlotItemSc a = TQwtPlotItem (CQwtPlotItemSc a) #

data CQwtPlotItemSc a #

qCastList_QwtPlotItem :: QqCastList_QwtPlotItem a r => a -> r #

withQwtPlotItemResult :: IO (Ptr (TQwtPlotItem a)) -> IO (QwtPlotItem a) #

withQListQwtPlotItemResult :: IO (Ptr (TQListQwtPlotItem ())) -> IO [QwtPlotItem ()] #

qwtPlotItemListFromPtrList :: [Ptr (TQwtPlotItem a)] -> IO [QwtPlotItem a] #

type QListQwtPlotItem a = Object (CQListQwtPlotItem a) #

type TQListQwtPlotItem a = CQListQwtPlotItem a #

data CQListQwtPlotItem a #

type QwtAbstractSeriesStore a = Object (CQwtAbstractSeriesStore a) #

type TQwtAbstractSeriesStore a = CQwtAbstractSeriesStore a #

data CQwtAbstractSeriesStore a #

qCast_QwtAbstractSeriesStore :: Object a -> IO (QwtAbstractSeriesStore ()) #

type QwtAbstractSeriesStoreSc a = QwtAbstractSeriesStore (CQwtAbstractSeriesStoreSc a) #

type TQwtAbstractSeriesStoreSc a = TQwtAbstractSeriesStore (CQwtAbstractSeriesStoreSc a) #

data CQwtAbstractSeriesStoreSc a #

qCastList_QwtAbstractSeriesStore :: QqCastList_QwtAbstractSeriesStore a r => a -> r #

withQwtAbstractSeriesStoreResult :: IO (Ptr (TQwtAbstractSeriesStore a)) -> IO (QwtAbstractSeriesStore a) #

type QwtPlotSeriesItem a = QwtPlotItem (CQwtPlotSeriesItem a) #

type TQwtPlotSeriesItem a = TQwtPlotItem (CQwtPlotSeriesItem a) #

data CQwtPlotSeriesItem a #

qCast_QwtPlotSeriesItem :: Object a -> IO (QwtPlotSeriesItem ()) #

type QwtPlotSeriesItemSc a = QwtPlotSeriesItem (CQwtPlotSeriesItemSc a) #

type TQwtPlotSeriesItemSc a = TQwtPlotSeriesItem (CQwtPlotSeriesItemSc a) #

data CQwtPlotSeriesItemSc a #

qCastList_QwtPlotSeriesItem :: QqCastList_QwtPlotSeriesItem a r => a -> r #

withQwtPlotSeriesItemResult :: IO (Ptr (TQwtPlotSeriesItem a)) -> IO (QwtPlotSeriesItem a) #

type QwtPickerMachine a = Object (CQwtPickerMachine a) #

type TQwtPickerMachine a = CQwtPickerMachine a #

data CQwtPickerMachine a #

qCast_QwtPickerMachine :: Object a -> IO (QwtPickerMachine ()) #

type QwtPickerMachineSc a = QwtPickerMachine (CQwtPickerMachineSc a) #

type TQwtPickerMachineSc a = TQwtPickerMachine (CQwtPickerMachineSc a) #

data CQwtPickerMachineSc a #

qCastList_QwtPickerMachine :: QqCastList_QwtPickerMachine a r => a -> r #

withQwtPickerMachineResult :: IO (Ptr (TQwtPickerMachine a)) -> IO (QwtPickerMachine a) #

type QwtAbstractScale a = QWidget (CQwtAbstractScale a) #

type TQwtAbstractScale a = TQWidget (CQwtAbstractScale a) #

data CQwtAbstractScale a #

qCast_QwtAbstractScale :: Object a -> IO (QwtAbstractScale ()) #

type QwtAbstractScaleSc a = QwtAbstractScale (CQwtAbstractScaleSc a) #

type TQwtAbstractScaleSc a = TQwtAbstractScale (CQwtAbstractScaleSc a) #

data CQwtAbstractScaleSc a #

qCastList_QwtAbstractScale :: QqCastList_QwtAbstractScale a r => a -> r #

withQwtAbstractScaleResult :: IO (Ptr (TQwtAbstractScale a)) -> IO (QwtAbstractScale a) #

qwtAbstractScaleFromPtr :: Ptr (TQwtAbstractScale a) -> IO (QwtAbstractScale a) #

qwtAbstractScaleAddFinalizer :: QwtAbstractScale a -> IO () #

type QwtAbstractSlider a = QwtAbstractScale (CQwtAbstractSlider a) #

type TQwtAbstractSlider a = TQwtAbstractScale (CQwtAbstractSlider a) #

data CQwtAbstractSlider a #

qCast_QwtAbstractSlider :: Object a -> IO (QwtAbstractSlider ()) #

type QwtAbstractSliderSc a = QwtAbstractSlider (CQwtAbstractSliderSc a) #

type TQwtAbstractSliderSc a = TQwtAbstractSlider (CQwtAbstractSliderSc a) #

data CQwtAbstractSliderSc a #

qCastList_QwtAbstractSlider :: QqCastList_QwtAbstractSlider a r => a -> r #

withQwtAbstractSliderResult :: IO (Ptr (TQwtAbstractSlider a)) -> IO (QwtAbstractSlider a) #

qwtAbstractSliderFromPtr :: Ptr (TQwtAbstractSlider a) -> IO (QwtAbstractSlider a) #

qwtAbstractSliderAddFinalizer :: QwtAbstractSlider a -> IO () #

type QwtAbstractScaleDraw a = Object (CQwtAbstractScaleDraw a) #

type TQwtAbstractScaleDraw a = CQwtAbstractScaleDraw a #

data CQwtAbstractScaleDraw a #

qCast_QwtAbstractScaleDraw :: Object a -> IO (QwtAbstractScaleDraw ()) #

type QwtAbstractScaleDrawSc a = QwtAbstractScaleDraw (CQwtAbstractScaleDrawSc a) #

type TQwtAbstractScaleDrawSc a = TQwtAbstractScaleDraw (CQwtAbstractScaleDrawSc a) #

data CQwtAbstractScaleDrawSc a #

qCastList_QwtAbstractScaleDraw :: QqCastList_QwtAbstractScaleDraw a r => a -> r #

withQwtAbstractScaleDrawResult :: IO (Ptr (TQwtAbstractScaleDraw a)) -> IO (QwtAbstractScaleDraw a) #

type QwtTransform a = Object (CQwtTransform a) #

type TQwtTransform a = CQwtTransform a #

data CQwtTransform a #

qCast_QwtTransform :: Object a -> IO (QwtTransform ()) #

type QwtTransformSc a = QwtTransform (CQwtTransformSc a) #

type TQwtTransformSc a = TQwtTransform (CQwtTransformSc a) #

data CQwtTransformSc a #

qCastList_QwtTransform :: QqCastList_QwtTransform a r => a -> r #

withQwtTransformResult :: IO (Ptr (TQwtTransform a)) -> IO (QwtTransform a) #

type QwtDialNeedle a = Object (CQwtDialNeedle a) #

type TQwtDialNeedle a = CQwtDialNeedle a #

data CQwtDialNeedle a #

qCast_QwtDialNeedle :: Object a -> IO (QwtDialNeedle ()) #

type QwtDialNeedleSc a = QwtDialNeedle (CQwtDialNeedleSc a) #

type TQwtDialNeedleSc a = TQwtDialNeedle (CQwtDialNeedleSc a) #

data CQwtDialNeedleSc a #

qCastList_QwtDialNeedle :: QqCastList_QwtDialNeedle a r => a -> r #

withQwtDialNeedleResult :: IO (Ptr (TQwtDialNeedle a)) -> IO (QwtDialNeedle a) #

type QwtEventPattern a = Object (CQwtEventPattern a) #

type TQwtEventPattern a = CQwtEventPattern a #

data CQwtEventPattern a #

qCast_QwtEventPattern :: Object a -> IO (QwtEventPattern ()) #

type QwtEventPatternSc a = QwtEventPattern (CQwtEventPatternSc a) #

type TQwtEventPatternSc a = TQwtEventPattern (CQwtEventPatternSc a) #

data CQwtEventPatternSc a #

qCastList_QwtEventPattern :: QqCastList_QwtEventPattern a r => a -> r #

withQwtEventPatternResult :: IO (Ptr (TQwtEventPattern a)) -> IO (QwtEventPattern a) #

type QwtScaleEngine a = Object (CQwtScaleEngine a) #

type TQwtScaleEngine a = CQwtScaleEngine a #

data CQwtScaleEngine a #

qCast_QwtScaleEngine :: Object a -> IO (QwtScaleEngine ()) #

type QwtScaleEngineSc a = QwtScaleEngine (CQwtScaleEngineSc a) #

type TQwtScaleEngineSc a = TQwtScaleEngine (CQwtScaleEngineSc a) #

data CQwtScaleEngineSc a #

qCastList_QwtScaleEngine :: QqCastList_QwtScaleEngine a r => a -> r #

withQwtScaleEngineResult :: IO (Ptr (TQwtScaleEngine a)) -> IO (QwtScaleEngine a) #

type QwtCurveFitter a = Object (CQwtCurveFitter a) #

type TQwtCurveFitter a = CQwtCurveFitter a #

data CQwtCurveFitter a #

qCast_QwtCurveFitter :: Object a -> IO (QwtCurveFitter ()) #

type QwtCurveFitterSc a = QwtCurveFitter (CQwtCurveFitterSc a) #

type TQwtCurveFitterSc a = TQwtCurveFitter (CQwtCurveFitterSc a) #

data CQwtCurveFitterSc a #

qCastList_QwtCurveFitter :: QqCastList_QwtCurveFitter a r => a -> r #

withQwtCurveFitterResult :: IO (Ptr (TQwtCurveFitter a)) -> IO (QwtCurveFitter a) #

type QwtColorMap a = Object (CQwtColorMap a) #

type TQwtColorMap a = CQwtColorMap a #

data CQwtColorMap a #

qCast_QwtColorMap :: Object a -> IO (QwtColorMap ()) #

type QwtColorMapSc a = QwtColorMap (CQwtColorMapSc a) #

type TQwtColorMapSc a = TQwtColorMap (CQwtColorMapSc a) #

data CQwtColorMapSc a #

qCastList_QwtColorMap :: QqCastList_QwtColorMap a r => a -> r #

withQwtColorMapResult :: IO (Ptr (TQwtColorMap a)) -> IO (QwtColorMap a) #

type QwtTextEngine a = Object (CQwtTextEngine a) #

type TQwtTextEngine a = CQwtTextEngine a #

data CQwtTextEngine a #

qCast_QwtTextEngine :: Object a -> IO (QwtTextEngine ()) #

type QwtTextEngineSc a = QwtTextEngine (CQwtTextEngineSc a) #

type TQwtTextEngineSc a = TQwtTextEngine (CQwtTextEngineSc a) #

data CQwtTextEngineSc a #

qCastList_QwtTextEngine :: QqCastList_QwtTextEngine a r => a -> r #

withQwtTextEngineResult :: IO (Ptr (TQwtTextEngine a)) -> IO (QwtTextEngine a) #

type QwtPicker a = QObject (CQwtPicker a) #

type TQwtPicker a = TQObject (CQwtPicker a) #

data CQwtPicker a #

qCast_QwtPicker :: Object a -> IO (QwtPicker ()) #

type QwtPickerSc a = QwtPicker (CQwtPickerSc a) #

type TQwtPickerSc a = TQwtPicker (CQwtPickerSc a) #

data CQwtPickerSc a #

qCastList_QwtPicker :: QqCastList_QwtPicker a r => a -> r #

withQwtPickerResult :: IO (Ptr (TQwtPicker a)) -> IO (QwtPicker a) #

qwtPickerFromPtr :: Ptr (TQwtPicker a) -> IO (QwtPicker a) #

qwtPickerAddFinalizer :: QwtPicker a -> IO () #

type QwtDial a = QwtAbstractSlider (CQwtDial a) #

type TQwtDial a = TQwtAbstractSlider (CQwtDial a) #

data CQwtDial a #

qCast_QwtDial :: Object a -> IO (QwtDial ()) #

type QwtDialSc a = QwtDial (CQwtDialSc a) #

type TQwtDialSc a = TQwtDial (CQwtDialSc a) #

data CQwtDialSc a #

qCastList_QwtDial :: QqCastList_QwtDial a r => a -> r #

withQwtDialResult :: IO (Ptr (TQwtDial a)) -> IO (QwtDial a) #

qwtDialFromPtr :: Ptr (TQwtDial a) -> IO (QwtDial a) #

qwtDialAddFinalizer :: QwtDial a -> IO () #

type QwtPlotAbstractBarChart a = QwtPlotSeriesItem (CQwtPlotAbstractBarChart a) #

type TQwtPlotAbstractBarChart a = TQwtPlotSeriesItem (CQwtPlotAbstractBarChart a) #

data CQwtPlotAbstractBarChart a #

qCast_QwtPlotAbstractBarChart :: Object a -> IO (QwtPlotAbstractBarChart ()) #

type QwtPlotAbstractBarChartSc a = QwtPlotAbstractBarChart (CQwtPlotAbstractBarChartSc a) #

type TQwtPlotAbstractBarChartSc a = TQwtPlotAbstractBarChart (CQwtPlotAbstractBarChartSc a) #

data CQwtPlotAbstractBarChartSc a #

qCastList_QwtPlotAbstractBarChart :: QqCastList_QwtPlotAbstractBarChart a r => a -> r #

withQwtPlotAbstractBarChartResult :: IO (Ptr (TQwtPlotAbstractBarChart a)) -> IO (QwtPlotAbstractBarChart a) #

type QwtCompassRose a = Object (CQwtCompassRose a) #

type TQwtCompassRose a = CQwtCompassRose a #

data CQwtCompassRose a #

qCast_QwtCompassRose :: Object a -> IO (QwtCompassRose ()) #

type QwtCompassRoseSc a = QwtCompassRose (CQwtCompassRoseSc a) #

type TQwtCompassRoseSc a = TQwtCompassRose (CQwtCompassRoseSc a) #

data CQwtCompassRoseSc a #

qCastList_QwtCompassRose :: QqCastList_QwtCompassRose a r => a -> r #

withQwtCompassRoseResult :: IO (Ptr (TQwtCompassRose a)) -> IO (QwtCompassRose a) #

type QwtPlotDict a = Object (CQwtPlotDict a) #

type TQwtPlotDict a = CQwtPlotDict a #

data CQwtPlotDict a #

qCast_QwtPlotDict :: Object a -> IO (QwtPlotDict ()) #

type QwtPlotDictSc a = QwtPlotDict (CQwtPlotDictSc a) #

type TQwtPlotDictSc a = TQwtPlotDict (CQwtPlotDictSc a) #

data CQwtPlotDictSc a #

qCastList_QwtPlotDict :: QqCastList_QwtPlotDict a r => a -> r #

withQwtPlotDictResult :: IO (Ptr (TQwtPlotDict a)) -> IO (QwtPlotDict a) #

type QwtRasterData a = Object (CQwtRasterData a) #

type TQwtRasterData a = CQwtRasterData a #

data CQwtRasterData a #

qCast_QwtRasterData :: Object a -> IO (QwtRasterData ()) #

type QwtRasterDataSc a = QwtRasterData (CQwtRasterDataSc a) #

type TQwtRasterDataSc a = TQwtRasterData (CQwtRasterDataSc a) #

data CQwtRasterDataSc a #

qCastList_QwtRasterData :: QqCastList_QwtRasterData a r => a -> r #

withQwtRasterDataResult :: IO (Ptr (TQwtRasterData a)) -> IO (QwtRasterData a) #

type QwtMagnifier a = QObject (CQwtMagnifier a) #

type TQwtMagnifier a = TQObject (CQwtMagnifier a) #

data CQwtMagnifier a #

qCast_QwtMagnifier :: Object a -> IO (QwtMagnifier ()) #

type QwtMagnifierSc a = QwtMagnifier (CQwtMagnifierSc a) #

type TQwtMagnifierSc a = TQwtMagnifier (CQwtMagnifierSc a) #

data CQwtMagnifierSc a #

qCastList_QwtMagnifier :: QqCastList_QwtMagnifier a r => a -> r #

withQwtMagnifierResult :: IO (Ptr (TQwtMagnifier a)) -> IO (QwtMagnifier a) #

qwtMagnifierFromPtr :: Ptr (TQwtMagnifier a) -> IO (QwtMagnifier a) #

qwtMagnifierAddFinalizer :: QwtMagnifier a -> IO () #

type QwtPanner a = QWidget (CQwtPanner a) #

type TQwtPanner a = TQWidget (CQwtPanner a) #

data CQwtPanner a #

qCast_QwtPanner :: Object a -> IO (QwtPanner ()) #

type QwtPannerSc a = QwtPanner (CQwtPannerSc a) #

type TQwtPannerSc a = TQwtPanner (CQwtPannerSc a) #

data CQwtPannerSc a #

qCastList_QwtPanner :: QqCastList_QwtPanner a r => a -> r #

withQwtPannerResult :: IO (Ptr (TQwtPanner a)) -> IO (QwtPanner a) #

qwtPannerFromPtr :: Ptr (TQwtPanner a) -> IO (QwtPanner a) #

qwtPannerAddFinalizer :: QwtPanner a -> IO () #

type QwtNullPaintDevice a = QPaintDevice (CQwtNullPaintDevice a) #

type TQwtNullPaintDevice a = TQPaintDevice (CQwtNullPaintDevice a) #

data CQwtNullPaintDevice a #

qCast_QwtNullPaintDevice :: Object a -> IO (QwtNullPaintDevice ()) #

type QwtNullPaintDeviceSc a = QwtNullPaintDevice (CQwtNullPaintDeviceSc a) #

type TQwtNullPaintDeviceSc a = TQwtNullPaintDevice (CQwtNullPaintDeviceSc a) #

data CQwtNullPaintDeviceSc a #

qCastList_QwtNullPaintDevice :: QqCastList_QwtNullPaintDevice a r => a -> r #

withQwtNullPaintDeviceResult :: IO (Ptr (TQwtNullPaintDevice a)) -> IO (QwtNullPaintDevice a) #

type QwtAbstractLegend a = QFrame (CQwtAbstractLegend a) #

type TQwtAbstractLegend a = TQFrame (CQwtAbstractLegend a) #

data CQwtAbstractLegend a #

qCast_QwtAbstractLegend :: Object a -> IO (QwtAbstractLegend ()) #

type QwtAbstractLegendSc a = QwtAbstractLegend (CQwtAbstractLegendSc a) #

type TQwtAbstractLegendSc a = TQwtAbstractLegend (CQwtAbstractLegendSc a) #

data CQwtAbstractLegendSc a #

qCastList_QwtAbstractLegend :: QqCastList_QwtAbstractLegend a r => a -> r #

withQwtAbstractLegendResult :: IO (Ptr (TQwtAbstractLegend a)) -> IO (QwtAbstractLegend a) #

qwtAbstractLegendFromPtr :: Ptr (TQwtAbstractLegend a) -> IO (QwtAbstractLegend a) #

qwtAbstractLegendAddFinalizer :: QwtAbstractLegend a -> IO () #

type QwtTextLabel a = QFrame (CQwtTextLabel a) #

type TQwtTextLabel a = TQFrame (CQwtTextLabel a) #

data CQwtTextLabel a #

qCast_QwtTextLabel :: Object a -> IO (QwtTextLabel ()) #

type QwtTextLabelSc a = QwtTextLabel (CQwtTextLabelSc a) #

type TQwtTextLabelSc a = TQwtTextLabel (CQwtTextLabelSc a) #

data CQwtTextLabelSc a #

qCastList_QwtTextLabel :: QqCastList_QwtTextLabel a r => a -> r #

withQwtTextLabelResult :: IO (Ptr (TQwtTextLabel a)) -> IO (QwtTextLabel a) #

qwtTextLabelFromPtr :: Ptr (TQwtTextLabel a) -> IO (QwtTextLabel a) #

qwtTextLabelAddFinalizer :: QwtTextLabel a -> IO () #

type QwtRoundScaleDraw a = QwtAbstractScaleDraw (CQwtRoundScaleDraw a) #

type TQwtRoundScaleDraw a = TQwtAbstractScaleDraw (CQwtRoundScaleDraw a) #

data CQwtRoundScaleDraw a #

qCast_QwtRoundScaleDraw :: Object a -> IO (QwtRoundScaleDraw ()) #

type QwtRoundScaleDrawSc a = QwtRoundScaleDraw (CQwtRoundScaleDrawSc a) #

type TQwtRoundScaleDrawSc a = TQwtRoundScaleDraw (CQwtRoundScaleDrawSc a) #

data CQwtRoundScaleDrawSc a #

qCastList_QwtRoundScaleDraw :: QqCastList_QwtRoundScaleDraw a r => a -> r #

withQwtRoundScaleDrawResult :: IO (Ptr (TQwtRoundScaleDraw a)) -> IO (QwtRoundScaleDraw a) #

type QwtScaleDraw a = QwtAbstractScaleDraw (CQwtScaleDraw a) #

type TQwtScaleDraw a = TQwtAbstractScaleDraw (CQwtScaleDraw a) #

data CQwtScaleDraw a #

qCast_QwtScaleDraw :: Object a -> IO (QwtScaleDraw ()) #

type QwtScaleDrawSc a = QwtScaleDraw (CQwtScaleDrawSc a) #

type TQwtScaleDrawSc a = TQwtScaleDraw (CQwtScaleDrawSc a) #

data CQwtScaleDrawSc a #

qCastList_QwtScaleDraw :: QqCastList_QwtScaleDraw a r => a -> r #

withQwtScaleDrawResult :: IO (Ptr (TQwtScaleDraw a)) -> IO (QwtScaleDraw a) #

type QwtPlotPicker a = QwtPicker (CQwtPlotPicker a) #

type TQwtPlotPicker a = TQwtPicker (CQwtPlotPicker a) #

data CQwtPlotPicker a #

qCast_QwtPlotPicker :: Object a -> IO (QwtPlotPicker ()) #

type QwtPlotPickerSc a = QwtPlotPicker (CQwtPlotPickerSc a) #

type TQwtPlotPickerSc a = TQwtPlotPicker (CQwtPlotPickerSc a) #

data CQwtPlotPickerSc a #

qCastList_QwtPlotPicker :: QqCastList_QwtPlotPicker a r => a -> r #

withQwtPlotPickerResult :: IO (Ptr (TQwtPlotPicker a)) -> IO (QwtPlotPicker a) #

qwtPlotPickerFromPtr :: Ptr (TQwtPlotPicker a) -> IO (QwtPlotPicker a) #

qwtPlotPickerAddFinalizer :: QwtPlotPicker a -> IO () #

type QwtPlotRasterItem a = QwtPlotItem (CQwtPlotRasterItem a) #

type TQwtPlotRasterItem a = TQwtPlotItem (CQwtPlotRasterItem a) #

data CQwtPlotRasterItem a #

qCast_QwtPlotRasterItem :: Object a -> IO (QwtPlotRasterItem ()) #

type QwtPlotRasterItemSc a = QwtPlotRasterItem (CQwtPlotRasterItemSc a) #

type TQwtPlotRasterItemSc a = TQwtPlotRasterItem (CQwtPlotRasterItemSc a) #

data CQwtPlotRasterItemSc a #

qCastList_QwtPlotRasterItem :: QqCastList_QwtPlotRasterItem a r => a -> r #

withQwtPlotRasterItemResult :: IO (Ptr (TQwtPlotRasterItem a)) -> IO (QwtPlotRasterItem a) #

type QwtLinearScaleEngine a = QwtScaleEngine (CQwtLinearScaleEngine a) #

type TQwtLinearScaleEngine a = TQwtScaleEngine (CQwtLinearScaleEngine a) #

data CQwtLinearScaleEngine a #

qCast_QwtLinearScaleEngine :: Object a -> IO (QwtLinearScaleEngine ()) #

type QwtLinearScaleEngineSc a = QwtLinearScaleEngine (CQwtLinearScaleEngineSc a) #

type TQwtLinearScaleEngineSc a = TQwtLinearScaleEngine (CQwtLinearScaleEngineSc a) #

data CQwtLinearScaleEngineSc a #

qCastList_QwtLinearScaleEngine :: QqCastList_QwtLinearScaleEngine a r => a -> r #

withQwtLinearScaleEngineResult :: IO (Ptr (TQwtLinearScaleEngine a)) -> IO (QwtLinearScaleEngine a) #

type QwtEventPattern_MousePattern a = Object (CQwtEventPattern_MousePattern a) #

type TQwtEventPattern_MousePattern a = CQwtEventPattern_MousePattern a #

data CQwtEventPattern_MousePattern a #

qCast_QwtEventPattern_MousePattern :: Object a -> IO (QwtEventPattern_MousePattern ()) #

type QwtEventPattern_MousePatternSc a = QwtEventPattern_MousePattern (CQwtEventPattern_MousePatternSc a) #

type TQwtEventPattern_MousePatternSc a = TQwtEventPattern_MousePattern (CQwtEventPattern_MousePatternSc a) #

data CQwtEventPattern_MousePatternSc a #

qCastList_QwtEventPattern_MousePattern :: QqCastList_QwtEventPattern_MousePattern a r => a -> r #

withQwtEventPattern_MousePatternResult :: IO (Ptr (TQwtEventPattern_MousePattern a)) -> IO (QwtEventPattern_MousePattern a) #

withQVectorQwtEventPattern_MousePatternResult :: IO (Ptr (TQVectorQwtEventPattern_MousePattern ())) -> IO [QwtEventPattern_MousePattern ()] #

qwtEventPattern_MousePatternVectorFromPtrList :: [Ptr (TQwtEventPattern_MousePattern a)] -> IO [QwtEventPattern_MousePattern a] #

type QVectorQwtEventPattern_MousePattern a = Object (CQVectorQwtEventPattern_MousePattern a) #

type TQVectorQwtEventPattern_MousePattern a = CQVectorQwtEventPattern_MousePattern a #

data CQVectorQwtEventPattern_MousePattern a #

type QwtPointMapper a = Object (CQwtPointMapper a) #

type TQwtPointMapper a = CQwtPointMapper a #

data CQwtPointMapper a #

qCast_QwtPointMapper :: Object a -> IO (QwtPointMapper ()) #

type QwtPointMapperSc a = QwtPointMapper (CQwtPointMapperSc a) #

type TQwtPointMapperSc a = TQwtPointMapper (CQwtPointMapperSc a) #

data CQwtPointMapperSc a #

qCastList_QwtPointMapper :: QqCastList_QwtPointMapper a r => a -> r #

withQwtPointMapperResult :: IO (Ptr (TQwtPointMapper a)) -> IO (QwtPointMapper a) #

type QwtIntervalSymbol a = Object (CQwtIntervalSymbol a) #

type TQwtIntervalSymbol a = CQwtIntervalSymbol a #

data CQwtIntervalSymbol a #

qCast_QwtIntervalSymbol :: Object a -> IO (QwtIntervalSymbol ()) #

type QwtIntervalSymbolSc a = QwtIntervalSymbol (CQwtIntervalSymbolSc a) #

type TQwtIntervalSymbolSc a = TQwtIntervalSymbol (CQwtIntervalSymbolSc a) #

data CQwtIntervalSymbolSc a #

qCastList_QwtIntervalSymbol :: QqCastList_QwtIntervalSymbol a r => a -> r #

withQwtIntervalSymbolResult :: IO (Ptr (TQwtIntervalSymbol a)) -> IO (QwtIntervalSymbol a) #

type QwtEventPattern_KeyPattern a = Object (CQwtEventPattern_KeyPattern a) #

type TQwtEventPattern_KeyPattern a = CQwtEventPattern_KeyPattern a #

data CQwtEventPattern_KeyPattern a #

qCast_QwtEventPattern_KeyPattern :: Object a -> IO (QwtEventPattern_KeyPattern ()) #

type QwtEventPattern_KeyPatternSc a = QwtEventPattern_KeyPattern (CQwtEventPattern_KeyPatternSc a) #

type TQwtEventPattern_KeyPatternSc a = TQwtEventPattern_KeyPattern (CQwtEventPattern_KeyPatternSc a) #

data CQwtEventPattern_KeyPatternSc a #

qCastList_QwtEventPattern_KeyPattern :: QqCastList_QwtEventPattern_KeyPattern a r => a -> r #

withQwtEventPattern_KeyPatternResult :: IO (Ptr (TQwtEventPattern_KeyPattern a)) -> IO (QwtEventPattern_KeyPattern a) #

withQVectorQwtEventPattern_KeyPatternResult :: IO (Ptr (TQVectorQwtEventPattern_KeyPattern ())) -> IO [QwtEventPattern_KeyPattern ()] #

qwtEventPattern_KeyPatternVectorFromPtrList :: [Ptr (TQwtEventPattern_KeyPattern a)] -> IO [QwtEventPattern_KeyPattern a] #

type QVectorQwtEventPattern_KeyPattern a = Object (CQVectorQwtEventPattern_KeyPattern a) #

type TQVectorQwtEventPattern_KeyPattern a = CQVectorQwtEventPattern_KeyPattern a #

data CQVectorQwtEventPattern_KeyPattern a #

type QwtColumnRect a = Object (CQwtColumnRect a) #

type TQwtColumnRect a = CQwtColumnRect a #

data CQwtColumnRect a #

qCast_QwtColumnRect :: Object a -> IO (QwtColumnRect ()) #

type QwtColumnRectSc a = QwtColumnRect (CQwtColumnRectSc a) #

type TQwtColumnRectSc a = TQwtColumnRect (CQwtColumnRectSc a) #

data CQwtColumnRectSc a #

qCastList_QwtColumnRect :: QqCastList_QwtColumnRect a r => a -> r #

withQwtColumnRectResult :: IO (Ptr (TQwtColumnRect a)) -> IO (QwtColumnRect a) #

type QwtInterval a = Object (CQwtInterval a) #

type TQwtInterval a = CQwtInterval a #

data CQwtInterval a #

qCast_QwtInterval :: Object a -> IO (QwtInterval ()) #

type QwtIntervalSc a = QwtInterval (CQwtIntervalSc a) #

type TQwtIntervalSc a = TQwtInterval (CQwtIntervalSc a) #

data CQwtIntervalSc a #

qCastList_QwtInterval :: QqCastList_QwtInterval a r => a -> r #

withQwtIntervalResult :: IO (Ptr (TQwtInterval a)) -> IO (QwtInterval a) #

withQVectorQwtIntervalResult :: IO (Ptr (TQVectorQwtInterval ())) -> IO [QwtInterval ()] #

qwtIntervalVectorFromPtrList :: [Ptr (TQwtInterval a)] -> IO [QwtInterval a] #

type QVectorQwtInterval a = Object (CQVectorQwtInterval a) #

type TQVectorQwtInterval a = CQVectorQwtInterval a #

data CQVectorQwtInterval a #

type QwtColumnSymbol a = Object (CQwtColumnSymbol a) #

type TQwtColumnSymbol a = CQwtColumnSymbol a #

data CQwtColumnSymbol a #

qCast_QwtColumnSymbol :: Object a -> IO (QwtColumnSymbol ()) #

type QwtColumnSymbolSc a = QwtColumnSymbol (CQwtColumnSymbolSc a) #

type TQwtColumnSymbolSc a = TQwtColumnSymbol (CQwtColumnSymbolSc a) #

data CQwtColumnSymbolSc a #

qCastList_QwtColumnSymbol :: QqCastList_QwtColumnSymbol a r => a -> r #

withQwtColumnSymbolResult :: IO (Ptr (TQwtColumnSymbol a)) -> IO (QwtColumnSymbol a) #

type QwtClipper a = Object (CQwtClipper a) #

type TQwtClipper a = CQwtClipper a #

data CQwtClipper a #

qCast_QwtClipper :: Object a -> IO (QwtClipper ()) #

type QwtClipperSc a = QwtClipper (CQwtClipperSc a) #

type TQwtClipperSc a = TQwtClipper (CQwtClipperSc a) #

data CQwtClipperSc a #

qCastList_QwtClipper :: QqCastList_QwtClipper a r => a -> r #

withQwtClipperResult :: IO (Ptr (TQwtClipper a)) -> IO (QwtClipper a) #

type QwtScaleMap a = Object (CQwtScaleMap a) #

type TQwtScaleMap a = CQwtScaleMap a #

data CQwtScaleMap a #

qCast_QwtScaleMap :: Object a -> IO (QwtScaleMap ()) #

type QwtScaleMapSc a = QwtScaleMap (CQwtScaleMapSc a) #

type TQwtScaleMapSc a = TQwtScaleMap (CQwtScaleMapSc a) #

data CQwtScaleMapSc a #

qCastList_QwtScaleMap :: QqCastList_QwtScaleMap a r => a -> r #

withQwtScaleMapResult :: IO (Ptr (TQwtScaleMap a)) -> IO (QwtScaleMap a) #

type QwtOHLCSample a = Object (CQwtOHLCSample a) #

type TQwtOHLCSample a = CQwtOHLCSample a #

data CQwtOHLCSample a #

qCast_QwtOHLCSample :: Object a -> IO (QwtOHLCSample ()) #

type QwtOHLCSampleSc a = QwtOHLCSample (CQwtOHLCSampleSc a) #

type TQwtOHLCSampleSc a = TQwtOHLCSample (CQwtOHLCSampleSc a) #

data CQwtOHLCSampleSc a #

qCastList_QwtOHLCSample :: QqCastList_QwtOHLCSample a r => a -> r #

withQwtOHLCSampleResult :: IO (Ptr (TQwtOHLCSample a)) -> IO (QwtOHLCSample a) #

type QwtPainterCommand_PixmapData a = Object (CQwtPainterCommand_PixmapData a) #

type TQwtPainterCommand_PixmapData a = CQwtPainterCommand_PixmapData a #

data CQwtPainterCommand_PixmapData a #

qCast_QwtPainterCommand_PixmapData :: Object a -> IO (QwtPainterCommand_PixmapData ()) #

type QwtPainterCommand_PixmapDataSc a = QwtPainterCommand_PixmapData (CQwtPainterCommand_PixmapDataSc a) #

type TQwtPainterCommand_PixmapDataSc a = TQwtPainterCommand_PixmapData (CQwtPainterCommand_PixmapDataSc a) #

data CQwtPainterCommand_PixmapDataSc a #

qCastList_QwtPainterCommand_PixmapData :: QqCastList_QwtPainterCommand_PixmapData a r => a -> r #

withQwtPainterCommand_PixmapDataResult :: IO (Ptr (TQwtPainterCommand_PixmapData a)) -> IO (QwtPainterCommand_PixmapData a) #

type QwtScaleArithmetic a = Object (CQwtScaleArithmetic a) #

type TQwtScaleArithmetic a = CQwtScaleArithmetic a #

data CQwtScaleArithmetic a #

qCast_QwtScaleArithmetic :: Object a -> IO (QwtScaleArithmetic ()) #

type QwtScaleArithmeticSc a = QwtScaleArithmetic (CQwtScaleArithmeticSc a) #

type TQwtScaleArithmeticSc a = TQwtScaleArithmetic (CQwtScaleArithmeticSc a) #

data CQwtScaleArithmeticSc a #

qCastList_QwtScaleArithmetic :: QqCastList_QwtScaleArithmetic a r => a -> r #

withQwtScaleArithmeticResult :: IO (Ptr (TQwtScaleArithmetic a)) -> IO (QwtScaleArithmetic a) #

type QwtPointSeriesData a = Object (CQwtPointSeriesData a) #

type TQwtPointSeriesData a = CQwtPointSeriesData a #

data CQwtPointSeriesData a #

qCast_QwtPointSeriesData :: Object a -> IO (QwtPointSeriesData ()) #

type QwtPointSeriesDataSc a = QwtPointSeriesData (CQwtPointSeriesDataSc a) #

type TQwtPointSeriesDataSc a = TQwtPointSeriesData (CQwtPointSeriesDataSc a) #

data CQwtPointSeriesDataSc a #

qCastList_QwtPointSeriesData :: QqCastList_QwtPointSeriesData a r => a -> r #

type QwtPainterCommand a = Object (CQwtPainterCommand a) #

type TQwtPainterCommand a = CQwtPainterCommand a #

data CQwtPainterCommand a #

qCast_QwtPainterCommand :: Object a -> IO (QwtPainterCommand ()) #

type QwtPainterCommandSc a = QwtPainterCommand (CQwtPainterCommandSc a) #

type TQwtPainterCommandSc a = TQwtPainterCommand (CQwtPainterCommandSc a) #

data CQwtPainterCommandSc a #

qCastList_QwtPainterCommand :: QqCastList_QwtPainterCommand a r => a -> r #

withQwtPainterCommandResult :: IO (Ptr (TQwtPainterCommand a)) -> IO (QwtPainterCommand a) #

withQVectorQwtPainterCommandResult :: IO (Ptr (TQVectorQwtPainterCommand ())) -> IO [QwtPainterCommand ()] #

qwtPainterCommandVectorFromPtrList :: [Ptr (TQwtPainterCommand a)] -> IO [QwtPainterCommand a] #

type QVectorQwtPainterCommand a = Object (CQVectorQwtPainterCommand a) #

type TQVectorQwtPainterCommand a = CQVectorQwtPainterCommand a #

data CQVectorQwtPainterCommand a #

type QwtSetSample a = Object (CQwtSetSample a) #

type TQwtSetSample a = CQwtSetSample a #

data CQwtSetSample a #

qCast_QwtSetSample :: Object a -> IO (QwtSetSample ()) #

type QwtSetSampleSc a = QwtSetSample (CQwtSetSampleSc a) #

type TQwtSetSampleSc a = TQwtSetSample (CQwtSetSampleSc a) #

data CQwtSetSampleSc a #

qCastList_QwtSetSample :: QqCastList_QwtSetSample a r => a -> r #

withQwtSetSampleResult :: IO (Ptr (TQwtSetSample a)) -> IO (QwtSetSample a) #

type QwtSystemClock a = Object (CQwtSystemClock a) #

type TQwtSystemClock a = CQwtSystemClock a #

data CQwtSystemClock a #

qCast_QwtSystemClock :: Object a -> IO (QwtSystemClock ()) #

type QwtSystemClockSc a = QwtSystemClock (CQwtSystemClockSc a) #

type TQwtSystemClockSc a = TQwtSystemClock (CQwtSystemClockSc a) #

data CQwtSystemClockSc a #

qCastList_QwtSystemClock :: QqCastList_QwtSystemClock a r => a -> r #

withQwtSystemClockResult :: IO (Ptr (TQwtSystemClock a)) -> IO (QwtSystemClock a) #

type QwtLegendData a = Object (CQwtLegendData a) #

type TQwtLegendData a = CQwtLegendData a #

data CQwtLegendData a #

qCast_QwtLegendData :: Object a -> IO (QwtLegendData ()) #

type QwtLegendDataSc a = QwtLegendData (CQwtLegendDataSc a) #

type TQwtLegendDataSc a = TQwtLegendData (CQwtLegendDataSc a) #

data CQwtLegendDataSc a #

qCastList_QwtLegendData :: QqCastList_QwtLegendData a r => a -> r #

withQwtLegendDataResult :: IO (Ptr (TQwtLegendData a)) -> IO (QwtLegendData a) #

withQListQwtLegendDataResult :: IO (Ptr (TQListQwtLegendData ())) -> IO [QwtLegendData ()] #

qwtLegendDataListFromPtrList :: [Ptr (TQwtLegendData a)] -> IO [QwtLegendData a] #

type QListQwtLegendData a = Object (CQListQwtLegendData a) #

type TQListQwtLegendData a = CQListQwtLegendData a #

data CQListQwtLegendData a #

type QwtSymbol a = Object (CQwtSymbol a) #

type TQwtSymbol a = CQwtSymbol a #

data CQwtSymbol a #

qCast_QwtSymbol :: Object a -> IO (QwtSymbol ()) #

type QwtSymbolSc a = QwtSymbol (CQwtSymbolSc a) #

type TQwtSymbolSc a = TQwtSymbol (CQwtSymbolSc a) #

data CQwtSymbolSc a #

qCastList_QwtSymbol :: QqCastList_QwtSymbol a r => a -> r #

withQwtSymbolResult :: IO (Ptr (TQwtSymbol a)) -> IO (QwtSymbol a) #

type QwtPointArrayData a = Object (CQwtPointArrayData a) #

type TQwtPointArrayData a = CQwtPointArrayData a #

data CQwtPointArrayData a #

qCast_QwtPointArrayData :: Object a -> IO (QwtPointArrayData ()) #

type QwtPointArrayDataSc a = QwtPointArrayData (CQwtPointArrayDataSc a) #

type TQwtPointArrayDataSc a = TQwtPointArrayData (CQwtPointArrayDataSc a) #

data CQwtPointArrayDataSc a #

qCastList_QwtPointArrayData :: QqCastList_QwtPointArrayData a r => a -> r #

type QwtDate a = Object (CQwtDate a) #

type TQwtDate a = CQwtDate a #

data CQwtDate a #

qCast_QwtDate :: Object a -> IO (QwtDate ()) #

type QwtDateSc a = QwtDate (CQwtDateSc a) #

type TQwtDateSc a = TQwtDate (CQwtDateSc a) #

data CQwtDateSc a #

qCastList_QwtDate :: QqCastList_QwtDate a r => a -> r #

withQwtDateResult :: IO (Ptr (TQwtDate a)) -> IO (QwtDate a) #

type QwtSyntheticPointData a = Object (CQwtSyntheticPointData a) #

type TQwtSyntheticPointData a = CQwtSyntheticPointData a #

data CQwtSyntheticPointData a #

qCast_QwtSyntheticPointData :: Object a -> IO (QwtSyntheticPointData ()) #

type QwtSyntheticPointDataSc a = QwtSyntheticPointData (CQwtSyntheticPointDataSc a) #

type TQwtSyntheticPointDataSc a = TQwtSyntheticPointData (CQwtSyntheticPointDataSc a) #

data CQwtSyntheticPointDataSc a #

qCastList_QwtSyntheticPointData :: QqCastList_QwtSyntheticPointData a r => a -> r #

type QwtPoint3D a = Object (CQwtPoint3D a) #

type TQwtPoint3D a = CQwtPoint3D a #

data CQwtPoint3D a #

qCast_QwtPoint3D :: Object a -> IO (QwtPoint3D ()) #

type QwtPoint3DSc a = QwtPoint3D (CQwtPoint3DSc a) #

type TQwtPoint3DSc a = TQwtPoint3D (CQwtPoint3DSc a) #

data CQwtPoint3DSc a #

qCastList_QwtPoint3D :: QqCastList_QwtPoint3D a r => a -> r #

withQwtPoint3DResult :: IO (Ptr (TQwtPoint3D a)) -> IO (QwtPoint3D a) #

type QwtCPointerData a = Object (CQwtCPointerData a) #

type TQwtCPointerData a = CQwtCPointerData a #

data CQwtCPointerData a #

qCast_QwtCPointerData :: Object a -> IO (QwtCPointerData ()) #

type QwtCPointerDataSc a = QwtCPointerData (CQwtCPointerDataSc a) #

type TQwtCPointerDataSc a = TQwtCPointerData (CQwtCPointerDataSc a) #

data CQwtCPointerDataSc a #

qCastList_QwtCPointerData :: QqCastList_QwtCPointerData a r => a -> r #

type QwtIntervalSeriesData a = Object (CQwtIntervalSeriesData a) #

type TQwtIntervalSeriesData a = CQwtIntervalSeriesData a #

data CQwtIntervalSeriesData a #

qCast_QwtIntervalSeriesData :: Object a -> IO (QwtIntervalSeriesData ()) #

type QwtIntervalSeriesDataSc a = QwtIntervalSeriesData (CQwtIntervalSeriesDataSc a) #

type TQwtIntervalSeriesDataSc a = TQwtIntervalSeriesData (CQwtIntervalSeriesDataSc a) #

data CQwtIntervalSeriesDataSc a #

qCastList_QwtIntervalSeriesData :: QqCastList_QwtIntervalSeriesData a r => a -> r #

type QwtTradingChartData a = Object (CQwtTradingChartData a) #

type TQwtTradingChartData a = CQwtTradingChartData a #

data CQwtTradingChartData a #

qCast_QwtTradingChartData :: Object a -> IO (QwtTradingChartData ()) #

type QwtTradingChartDataSc a = QwtTradingChartData (CQwtTradingChartDataSc a) #

type TQwtTradingChartDataSc a = TQwtTradingChartData (CQwtTradingChartDataSc a) #

data CQwtTradingChartDataSc a #

qCastList_QwtTradingChartData :: QqCastList_QwtTradingChartData a r => a -> r #

type QwtPlotLayout a = Object (CQwtPlotLayout a) #

type TQwtPlotLayout a = CQwtPlotLayout a #

data CQwtPlotLayout a #

qCast_QwtPlotLayout :: Object a -> IO (QwtPlotLayout ()) #

type QwtPlotLayoutSc a = QwtPlotLayout (CQwtPlotLayoutSc a) #

type TQwtPlotLayoutSc a = TQwtPlotLayout (CQwtPlotLayoutSc a) #

data CQwtPlotLayoutSc a #

qCastList_QwtPlotLayout :: QqCastList_QwtPlotLayout a r => a -> r #

withQwtPlotLayoutResult :: IO (Ptr (TQwtPlotLayout a)) -> IO (QwtPlotLayout a) #

type QwtSpline a = Object (CQwtSpline a) #

type TQwtSpline a = CQwtSpline a #

data CQwtSpline a #

qCast_QwtSpline :: Object a -> IO (QwtSpline ()) #

type QwtSplineSc a = QwtSpline (CQwtSplineSc a) #

type TQwtSplineSc a = TQwtSpline (CQwtSplineSc a) #

data CQwtSplineSc a #

qCastList_QwtSpline :: QqCastList_QwtSpline a r => a -> r #

withQwtSplineResult :: IO (Ptr (TQwtSpline a)) -> IO (QwtSpline a) #

type QwtPointPolar a = Object (CQwtPointPolar a) #

type TQwtPointPolar a = CQwtPointPolar a #

data CQwtPointPolar a #

qCast_QwtPointPolar :: Object a -> IO (QwtPointPolar ()) #

type QwtPointPolarSc a = QwtPointPolar (CQwtPointPolarSc a) #

type TQwtPointPolarSc a = TQwtPointPolar (CQwtPointPolarSc a) #

data CQwtPointPolarSc a #

qCastList_QwtPointPolar :: QqCastList_QwtPointPolar a r => a -> r #

withQwtPointPolarResult :: IO (Ptr (TQwtPointPolar a)) -> IO (QwtPointPolar a) #

type QwtPainter a = Object (CQwtPainter a) #

type TQwtPainter a = CQwtPainter a #

data CQwtPainter a #

qCast_QwtPainter :: Object a -> IO (QwtPainter ()) #

type QwtPainterSc a = QwtPainter (CQwtPainterSc a) #

type TQwtPainterSc a = TQwtPainter (CQwtPainterSc a) #

data CQwtPainterSc a #

qCastList_QwtPainter :: QqCastList_QwtPainter a r => a -> r #

withQwtPainterResult :: IO (Ptr (TQwtPainter a)) -> IO (QwtPainter a) #

type QwtSetSeriesData a = Object (CQwtSetSeriesData a) #

type TQwtSetSeriesData a = CQwtSetSeriesData a #

data CQwtSetSeriesData a #

qCast_QwtSetSeriesData :: Object a -> IO (QwtSetSeriesData ()) #

type QwtSetSeriesDataSc a = QwtSetSeriesData (CQwtSetSeriesDataSc a) #

type TQwtSetSeriesDataSc a = TQwtSetSeriesData (CQwtSetSeriesDataSc a) #

data CQwtSetSeriesDataSc a #

qCastList_QwtSetSeriesData :: QqCastList_QwtSetSeriesData a r => a -> r #

type QwtPainterCommand_StateData a = Object (CQwtPainterCommand_StateData a) #

type TQwtPainterCommand_StateData a = CQwtPainterCommand_StateData a #

data CQwtPainterCommand_StateData a #

qCast_QwtPainterCommand_StateData :: Object a -> IO (QwtPainterCommand_StateData ()) #

type QwtPainterCommand_StateDataSc a = QwtPainterCommand_StateData (CQwtPainterCommand_StateDataSc a) #

type TQwtPainterCommand_StateDataSc a = TQwtPainterCommand_StateData (CQwtPainterCommand_StateDataSc a) #

data CQwtPainterCommand_StateDataSc a #

qCastList_QwtPainterCommand_StateData :: QqCastList_QwtPainterCommand_StateData a r => a -> r #

withQwtPainterCommand_StateDataResult :: IO (Ptr (TQwtPainterCommand_StateData a)) -> IO (QwtPainterCommand_StateData a) #

type QwtScaleDiv a = Object (CQwtScaleDiv a) #

type TQwtScaleDiv a = CQwtScaleDiv a #

data CQwtScaleDiv a #

qCast_QwtScaleDiv :: Object a -> IO (QwtScaleDiv ()) #

type QwtScaleDivSc a = QwtScaleDiv (CQwtScaleDivSc a) #

type TQwtScaleDivSc a = TQwtScaleDiv (CQwtScaleDivSc a) #

data CQwtScaleDivSc a #

qCastList_QwtScaleDiv :: QqCastList_QwtScaleDiv a r => a -> r #

withQwtScaleDivResult :: IO (Ptr (TQwtScaleDiv a)) -> IO (QwtScaleDiv a) #

type QwtIntervalSample a = Object (CQwtIntervalSample a) #

type TQwtIntervalSample a = CQwtIntervalSample a #

data CQwtIntervalSample a #

qCast_QwtIntervalSample :: Object a -> IO (QwtIntervalSample ()) #

type QwtIntervalSampleSc a = QwtIntervalSample (CQwtIntervalSampleSc a) #

type TQwtIntervalSampleSc a = TQwtIntervalSample (CQwtIntervalSampleSc a) #

data CQwtIntervalSampleSc a #

qCastList_QwtIntervalSample :: QqCastList_QwtIntervalSample a r => a -> r #

withQwtIntervalSampleResult :: IO (Ptr (TQwtIntervalSample a)) -> IO (QwtIntervalSample a) #

type QwtText a = Object (CQwtText a) #

type TQwtText a = CQwtText a #

data CQwtText a #

qCast_QwtText :: Object a -> IO (QwtText ()) #

type QwtTextSc a = QwtText (CQwtTextSc a) #

type TQwtTextSc a = TQwtText (CQwtTextSc a) #

data CQwtTextSc a #

qCastList_QwtText :: QqCastList_QwtText a r => a -> r #

withQwtTextResult :: IO (Ptr (TQwtText a)) -> IO (QwtText a) #

withQListQwtTextResult :: IO (Ptr (TQListQwtText ())) -> IO [QwtText ()] #

qwtTextListFromPtrList :: [Ptr (TQwtText a)] -> IO [QwtText a] #

type QListQwtText a = Object (CQListQwtText a) #

type TQListQwtText a = CQListQwtText a #

data CQListQwtText a #

type QwtPoint3DSeriesData a = Object (CQwtPoint3DSeriesData a) #

type TQwtPoint3DSeriesData a = CQwtPoint3DSeriesData a #

data CQwtPoint3DSeriesData a #

qCast_QwtPoint3DSeriesData :: Object a -> IO (QwtPoint3DSeriesData ()) #

type QwtPoint3DSeriesDataSc a = QwtPoint3DSeriesData (CQwtPoint3DSeriesDataSc a) #

type TQwtPoint3DSeriesDataSc a = TQwtPoint3DSeriesData (CQwtPoint3DSeriesDataSc a) #

data CQwtPoint3DSeriesDataSc a #

qCastList_QwtPoint3DSeriesData :: QqCastList_QwtPoint3DSeriesData a r => a -> r #

type QwtPainterCommand_ImageData a = Object (CQwtPainterCommand_ImageData a) #

type TQwtPainterCommand_ImageData a = CQwtPainterCommand_ImageData a #

data CQwtPainterCommand_ImageData a #

qCast_QwtPainterCommand_ImageData :: Object a -> IO (QwtPainterCommand_ImageData ()) #

type QwtPainterCommand_ImageDataSc a = QwtPainterCommand_ImageData (CQwtPainterCommand_ImageDataSc a) #

type TQwtPainterCommand_ImageDataSc a = TQwtPainterCommand_ImageData (CQwtPainterCommand_ImageDataSc a) #

data CQwtPainterCommand_ImageDataSc a #

qCastList_QwtPainterCommand_ImageData :: QqCastList_QwtPainterCommand_ImageData a r => a -> r #

withQwtPainterCommand_ImageDataResult :: IO (Ptr (TQwtPainterCommand_ImageData a)) -> IO (QwtPainterCommand_ImageData a) #

type QwtPixelMatrix a = QBitArray (CQwtPixelMatrix a) #

type TQwtPixelMatrix a = TQBitArray (CQwtPixelMatrix a) #

data CQwtPixelMatrix a #

qCast_QwtPixelMatrix :: Object a -> IO (QwtPixelMatrix ()) #

type QwtPixelMatrixSc a = QwtPixelMatrix (CQwtPixelMatrixSc a) #

type TQwtPixelMatrixSc a = TQwtPixelMatrix (CQwtPixelMatrixSc a) #

data CQwtPixelMatrixSc a #

qCastList_QwtPixelMatrix :: QqCastList_QwtPixelMatrix a r => a -> r #

withQwtPixelMatrixResult :: IO (Ptr (TQwtPixelMatrix a)) -> IO (QwtPixelMatrix a) #

type QwtPlotRenderer a = QObject (CQwtPlotRenderer a) #

type TQwtPlotRenderer a = TQObject (CQwtPlotRenderer a) #

data CQwtPlotRenderer a #

qCast_QwtPlotRenderer :: Object a -> IO (QwtPlotRenderer ()) #

type QwtPlotRendererSc a = QwtPlotRenderer (CQwtPlotRendererSc a) #

type TQwtPlotRendererSc a = TQwtPlotRenderer (CQwtPlotRendererSc a) #

data CQwtPlotRendererSc a #

qCastList_QwtPlotRenderer :: QqCastList_QwtPlotRenderer a r => a -> r #

withQwtPlotRendererResult :: IO (Ptr (TQwtPlotRenderer a)) -> IO (QwtPlotRenderer a) #

qwtPlotRendererFromPtr :: Ptr (TQwtPlotRenderer a) -> IO (QwtPlotRenderer a) #

qwtPlotRendererAddFinalizer :: QwtPlotRenderer a -> IO () #

type QwtPlotRescaler a = QObject (CQwtPlotRescaler a) #

type TQwtPlotRescaler a = TQObject (CQwtPlotRescaler a) #

data CQwtPlotRescaler a #

qCast_QwtPlotRescaler :: Object a -> IO (QwtPlotRescaler ()) #

type QwtPlotRescalerSc a = QwtPlotRescaler (CQwtPlotRescalerSc a) #

type TQwtPlotRescalerSc a = TQwtPlotRescaler (CQwtPlotRescalerSc a) #

data CQwtPlotRescalerSc a #

qCastList_QwtPlotRescaler :: QqCastList_QwtPlotRescaler a r => a -> r #

withQwtPlotRescalerResult :: IO (Ptr (TQwtPlotRescaler a)) -> IO (QwtPlotRescaler a) #

qwtPlotRescalerFromPtr :: Ptr (TQwtPlotRescaler a) -> IO (QwtPlotRescaler a) #

qwtPlotRescalerAddFinalizer :: QwtPlotRescaler a -> IO () #

type QwtSamplingThread a = QThread (CQwtSamplingThread a) #

type TQwtSamplingThread a = TQThread (CQwtSamplingThread a) #

data CQwtSamplingThread a #

qCast_QwtSamplingThread :: Object a -> IO (QwtSamplingThread ()) #

type QwtSamplingThreadSc a = QwtSamplingThread (CQwtSamplingThreadSc a) #

type TQwtSamplingThreadSc a = TQwtSamplingThread (CQwtSamplingThreadSc a) #

data CQwtSamplingThreadSc a #

qCastList_QwtSamplingThread :: QqCastList_QwtSamplingThread a r => a -> r #

withQwtSamplingThreadResult :: IO (Ptr (TQwtSamplingThread a)) -> IO (QwtSamplingThread a) #

qwtSamplingThreadFromPtr :: Ptr (TQwtSamplingThread a) -> IO (QwtSamplingThread a) #

qwtSamplingThreadAddFinalizer :: QwtSamplingThread a -> IO () #

type QwtCounter a = QWidget (CQwtCounter a) #

type TQwtCounter a = TQWidget (CQwtCounter a) #

data CQwtCounter a #

qCast_QwtCounter :: Object a -> IO (QwtCounter ()) #

type QwtCounterSc a = QwtCounter (CQwtCounterSc a) #

type TQwtCounterSc a = TQwtCounter (CQwtCounterSc a) #

data CQwtCounterSc a #

qCastList_QwtCounter :: QqCastList_QwtCounter a r => a -> r #

withQwtCounterResult :: IO (Ptr (TQwtCounter a)) -> IO (QwtCounter a) #

qwtCounterFromPtr :: Ptr (TQwtCounter a) -> IO (QwtCounter a) #

qwtCounterAddFinalizer :: QwtCounter a -> IO () #

type QwtWidgetOverlay a = QWidget (CQwtWidgetOverlay a) #

type TQwtWidgetOverlay a = TQWidget (CQwtWidgetOverlay a) #

data CQwtWidgetOverlay a #

qCast_QwtWidgetOverlay :: Object a -> IO (QwtWidgetOverlay ()) #

type QwtWidgetOverlaySc a = QwtWidgetOverlay (CQwtWidgetOverlaySc a) #

type TQwtWidgetOverlaySc a = TQwtWidgetOverlay (CQwtWidgetOverlaySc a) #

data CQwtWidgetOverlaySc a #

qCastList_QwtWidgetOverlay :: QqCastList_QwtWidgetOverlay a r => a -> r #

withQwtWidgetOverlayResult :: IO (Ptr (TQwtWidgetOverlay a)) -> IO (QwtWidgetOverlay a) #

qwtWidgetOverlayFromPtr :: Ptr (TQwtWidgetOverlay a) -> IO (QwtWidgetOverlay a) #

qwtWidgetOverlayAddFinalizer :: QwtWidgetOverlay a -> IO () #

type QwtScaleWidget a = QWidget (CQwtScaleWidget a) #

type TQwtScaleWidget a = TQWidget (CQwtScaleWidget a) #

data CQwtScaleWidget a #

qCast_QwtScaleWidget :: Object a -> IO (QwtScaleWidget ()) #

type QwtScaleWidgetSc a = QwtScaleWidget (CQwtScaleWidgetSc a) #

type TQwtScaleWidgetSc a = TQwtScaleWidget (CQwtScaleWidgetSc a) #

data CQwtScaleWidgetSc a #

qCastList_QwtScaleWidget :: QqCastList_QwtScaleWidget a r => a -> r #

withQwtScaleWidgetResult :: IO (Ptr (TQwtScaleWidget a)) -> IO (QwtScaleWidget a) #

qwtScaleWidgetFromPtr :: Ptr (TQwtScaleWidget a) -> IO (QwtScaleWidget a) #

qwtScaleWidgetAddFinalizer :: QwtScaleWidget a -> IO () #

type QwtWheel a = QWidget (CQwtWheel a) #

type TQwtWheel a = TQWidget (CQwtWheel a) #

data CQwtWheel a #

qCast_QwtWheel :: Object a -> IO (QwtWheel ()) #

type QwtWheelSc a = QwtWheel (CQwtWheelSc a) #

type TQwtWheelSc a = TQwtWheel (CQwtWheelSc a) #

data CQwtWheelSc a #

qCastList_QwtWheel :: QqCastList_QwtWheel a r => a -> r #

withQwtWheelResult :: IO (Ptr (TQwtWheel a)) -> IO (QwtWheel a) #

qwtWheelFromPtr :: Ptr (TQwtWheel a) -> IO (QwtWheel a) #

qwtWheelAddFinalizer :: QwtWheel a -> IO () #

type QwtPlotCanvas a = QFrame (CQwtPlotCanvas a) #

type TQwtPlotCanvas a = TQFrame (CQwtPlotCanvas a) #

data CQwtPlotCanvas a #

qCast_QwtPlotCanvas :: Object a -> IO (QwtPlotCanvas ()) #

type QwtPlotCanvasSc a = QwtPlotCanvas (CQwtPlotCanvasSc a) #

type TQwtPlotCanvasSc a = TQwtPlotCanvas (CQwtPlotCanvasSc a) #

data CQwtPlotCanvasSc a #

qCastList_QwtPlotCanvas :: QqCastList_QwtPlotCanvas a r => a -> r #

withQwtPlotCanvasResult :: IO (Ptr (TQwtPlotCanvas a)) -> IO (QwtPlotCanvas a) #

qwtPlotCanvasFromPtr :: Ptr (TQwtPlotCanvas a) -> IO (QwtPlotCanvas a) #

qwtPlotCanvasAddFinalizer :: QwtPlotCanvas a -> IO () #

type QwtPlot a = QFrame (CQwtPlot a) #

type TQwtPlot a = TQFrame (CQwtPlot a) #

data CQwtPlot a #

qCast_QwtPlot :: Object a -> IO (QwtPlot ()) #

type QwtPlotSc a = QwtPlot (CQwtPlotSc a) #

type TQwtPlotSc a = TQwtPlot (CQwtPlotSc a) #

data CQwtPlotSc a #

qCastList_QwtPlot :: QqCastList_QwtPlot a r => a -> r #

withQwtPlotResult :: IO (Ptr (TQwtPlot a)) -> IO (QwtPlot a) #

qwtPlotFromPtr :: Ptr (TQwtPlot a) -> IO (QwtPlot a) #

qwtPlotAddFinalizer :: QwtPlot a -> IO () #

type QwtDynGridLayout a = QLayout (CQwtDynGridLayout a) #

type TQwtDynGridLayout a = TQLayout (CQwtDynGridLayout a) #

data CQwtDynGridLayout a #

qCast_QwtDynGridLayout :: Object a -> IO (QwtDynGridLayout ()) #

type QwtDynGridLayoutSc a = QwtDynGridLayout (CQwtDynGridLayoutSc a) #

type TQwtDynGridLayoutSc a = TQwtDynGridLayout (CQwtDynGridLayoutSc a) #

data CQwtDynGridLayoutSc a #

qCastList_QwtDynGridLayout :: QqCastList_QwtDynGridLayout a r => a -> r #

withQwtDynGridLayoutResult :: IO (Ptr (TQwtDynGridLayout a)) -> IO (QwtDynGridLayout a) #

qwtDynGridLayoutFromPtr :: Ptr (TQwtDynGridLayout a) -> IO (QwtDynGridLayout a) #

qwtDynGridLayoutAddFinalizer :: QwtDynGridLayout a -> IO () #

type QwtArrowButton a = QPushButton (CQwtArrowButton a) #

type TQwtArrowButton a = TQPushButton (CQwtArrowButton a) #

data CQwtArrowButton a #

qCast_QwtArrowButton :: Object a -> IO (QwtArrowButton ()) #

type QwtArrowButtonSc a = QwtArrowButton (CQwtArrowButtonSc a) #

type TQwtArrowButtonSc a = TQwtArrowButton (CQwtArrowButtonSc a) #

data CQwtArrowButtonSc a #

qCastList_QwtArrowButton :: QqCastList_QwtArrowButton a r => a -> r #

withQwtArrowButtonResult :: IO (Ptr (TQwtArrowButton a)) -> IO (QwtArrowButton a) #

qwtArrowButtonFromPtr :: Ptr (TQwtArrowButton a) -> IO (QwtArrowButton a) #

qwtArrowButtonAddFinalizer :: QwtArrowButton a -> IO () #

type QwtPlotGLCanvas a = QGLWidget (CQwtPlotGLCanvas a) #

type TQwtPlotGLCanvas a = TQGLWidget (CQwtPlotGLCanvas a) #

data CQwtPlotGLCanvas a #

qCast_QwtPlotGLCanvas :: Object a -> IO (QwtPlotGLCanvas ()) #

type QwtPlotGLCanvasSc a = QwtPlotGLCanvas (CQwtPlotGLCanvasSc a) #

type TQwtPlotGLCanvasSc a = TQwtPlotGLCanvas (CQwtPlotGLCanvasSc a) #

data CQwtPlotGLCanvasSc a #

qCastList_QwtPlotGLCanvas :: QqCastList_QwtPlotGLCanvas a r => a -> r #

withQwtPlotGLCanvasResult :: IO (Ptr (TQwtPlotGLCanvas a)) -> IO (QwtPlotGLCanvas a) #

qwtPlotGLCanvasFromPtr :: Ptr (TQwtPlotGLCanvas a) -> IO (QwtPlotGLCanvas a) #

qwtPlotGLCanvasAddFinalizer :: QwtPlotGLCanvas a -> IO () #

type QwtLegend a = QwtAbstractLegend (CQwtLegend a) #

type TQwtLegend a = TQwtAbstractLegend (CQwtLegend a) #

data CQwtLegend a #

qCast_QwtLegend :: Object a -> IO (QwtLegend ()) #

type QwtLegendSc a = QwtLegend (CQwtLegendSc a) #

type TQwtLegendSc a = TQwtLegend (CQwtLegendSc a) #

data CQwtLegendSc a #

qCastList_QwtLegend :: QqCastList_QwtLegend a r => a -> r #

withQwtLegendResult :: IO (Ptr (TQwtLegend a)) -> IO (QwtLegend a) #

qwtLegendFromPtr :: Ptr (TQwtLegend a) -> IO (QwtLegend a) #

qwtLegendAddFinalizer :: QwtLegend a -> IO () #

type QwtThermo a = QwtAbstractScale (CQwtThermo a) #

type TQwtThermo a = TQwtAbstractScale (CQwtThermo a) #

data CQwtThermo a #

qCast_QwtThermo :: Object a -> IO (QwtThermo ()) #

type QwtThermoSc a = QwtThermo (CQwtThermoSc a) #

type TQwtThermoSc a = TQwtThermo (CQwtThermoSc a) #

data CQwtThermoSc a #

qCastList_QwtThermo :: QqCastList_QwtThermo a r => a -> r #

withQwtThermoResult :: IO (Ptr (TQwtThermo a)) -> IO (QwtThermo a) #

qwtThermoFromPtr :: Ptr (TQwtThermo a) -> IO (QwtThermo a) #

qwtThermoAddFinalizer :: QwtThermo a -> IO () #

type QwtKnob a = QwtAbstractSlider (CQwtKnob a) #

type TQwtKnob a = TQwtAbstractSlider (CQwtKnob a) #

data CQwtKnob a #

qCast_QwtKnob :: Object a -> IO (QwtKnob ()) #

type QwtKnobSc a = QwtKnob (CQwtKnobSc a) #

type TQwtKnobSc a = TQwtKnob (CQwtKnobSc a) #

data CQwtKnobSc a #

qCastList_QwtKnob :: QqCastList_QwtKnob a r => a -> r #

withQwtKnobResult :: IO (Ptr (TQwtKnob a)) -> IO (QwtKnob a) #

qwtKnobFromPtr :: Ptr (TQwtKnob a) -> IO (QwtKnob a) #

qwtKnobAddFinalizer :: QwtKnob a -> IO () #

type QwtSlider a = QwtAbstractSlider (CQwtSlider a) #

type TQwtSlider a = TQwtAbstractSlider (CQwtSlider a) #

data CQwtSlider a #

qCast_QwtSlider :: Object a -> IO (QwtSlider ()) #

type QwtSliderSc a = QwtSlider (CQwtSliderSc a) #

type TQwtSliderSc a = TQwtSlider (CQwtSliderSc a) #

data CQwtSliderSc a #

qCastList_QwtSlider :: QqCastList_QwtSlider a r => a -> r #

withQwtSliderResult :: IO (Ptr (TQwtSlider a)) -> IO (QwtSlider a) #

qwtSliderFromPtr :: Ptr (TQwtSlider a) -> IO (QwtSlider a) #

qwtSliderAddFinalizer :: QwtSlider a -> IO () #

type QwtAlphaColorMap a = QwtColorMap (CQwtAlphaColorMap a) #

type TQwtAlphaColorMap a = TQwtColorMap (CQwtAlphaColorMap a) #

data CQwtAlphaColorMap a #

qCast_QwtAlphaColorMap :: Object a -> IO (QwtAlphaColorMap ()) #

type QwtAlphaColorMapSc a = QwtAlphaColorMap (CQwtAlphaColorMapSc a) #

type TQwtAlphaColorMapSc a = TQwtAlphaColorMap (CQwtAlphaColorMapSc a) #

data CQwtAlphaColorMapSc a #

qCastList_QwtAlphaColorMap :: QqCastList_QwtAlphaColorMap a r => a -> r #

withQwtAlphaColorMapResult :: IO (Ptr (TQwtAlphaColorMap a)) -> IO (QwtAlphaColorMap a) #

type QwtLinearColorMap a = QwtColorMap (CQwtLinearColorMap a) #

type TQwtLinearColorMap a = TQwtColorMap (CQwtLinearColorMap a) #

data CQwtLinearColorMap a #

qCast_QwtLinearColorMap :: Object a -> IO (QwtLinearColorMap ()) #

type QwtLinearColorMapSc a = QwtLinearColorMap (CQwtLinearColorMapSc a) #

type TQwtLinearColorMapSc a = TQwtLinearColorMap (CQwtLinearColorMapSc a) #

data CQwtLinearColorMapSc a #

qCastList_QwtLinearColorMap :: QqCastList_QwtLinearColorMap a r => a -> r #

withQwtLinearColorMapResult :: IO (Ptr (TQwtLinearColorMap a)) -> IO (QwtLinearColorMap a) #

type QwtSimpleCompassRose a = QwtCompassRose (CQwtSimpleCompassRose a) #

type TQwtSimpleCompassRose a = TQwtCompassRose (CQwtSimpleCompassRose a) #

data CQwtSimpleCompassRose a #

qCast_QwtSimpleCompassRose :: Object a -> IO (QwtSimpleCompassRose ()) #

type QwtSimpleCompassRoseSc a = QwtSimpleCompassRose (CQwtSimpleCompassRoseSc a) #

type TQwtSimpleCompassRoseSc a = TQwtSimpleCompassRose (CQwtSimpleCompassRoseSc a) #

data CQwtSimpleCompassRoseSc a #

qCastList_QwtSimpleCompassRose :: QqCastList_QwtSimpleCompassRose a r => a -> r #

withQwtSimpleCompassRoseResult :: IO (Ptr (TQwtSimpleCompassRose a)) -> IO (QwtSimpleCompassRose a) #

type QwtWeedingCurveFitter a = QwtCurveFitter (CQwtWeedingCurveFitter a) #

type TQwtWeedingCurveFitter a = TQwtCurveFitter (CQwtWeedingCurveFitter a) #

data CQwtWeedingCurveFitter a #

qCast_QwtWeedingCurveFitter :: Object a -> IO (QwtWeedingCurveFitter ()) #

type QwtWeedingCurveFitterSc a = QwtWeedingCurveFitter (CQwtWeedingCurveFitterSc a) #

type TQwtWeedingCurveFitterSc a = TQwtWeedingCurveFitter (CQwtWeedingCurveFitterSc a) #

data CQwtWeedingCurveFitterSc a #

qCastList_QwtWeedingCurveFitter :: QqCastList_QwtWeedingCurveFitter a r => a -> r #

withQwtWeedingCurveFitterResult :: IO (Ptr (TQwtWeedingCurveFitter a)) -> IO (QwtWeedingCurveFitter a) #

type QwtSplineCurveFitter a = QwtCurveFitter (CQwtSplineCurveFitter a) #

type TQwtSplineCurveFitter a = TQwtCurveFitter (CQwtSplineCurveFitter a) #

data CQwtSplineCurveFitter a #

qCast_QwtSplineCurveFitter :: Object a -> IO (QwtSplineCurveFitter ()) #

type QwtSplineCurveFitterSc a = QwtSplineCurveFitter (CQwtSplineCurveFitterSc a) #

type TQwtSplineCurveFitterSc a = TQwtSplineCurveFitter (CQwtSplineCurveFitterSc a) #

data CQwtSplineCurveFitterSc a #

qCastList_QwtSplineCurveFitter :: QqCastList_QwtSplineCurveFitter a r => a -> r #

withQwtSplineCurveFitterResult :: IO (Ptr (TQwtSplineCurveFitter a)) -> IO (QwtSplineCurveFitter a) #

type QwtAnalogClock a = QwtDial (CQwtAnalogClock a) #

type TQwtAnalogClock a = TQwtDial (CQwtAnalogClock a) #

data CQwtAnalogClock a #

qCast_QwtAnalogClock :: Object a -> IO (QwtAnalogClock ()) #

type QwtAnalogClockSc a = QwtAnalogClock (CQwtAnalogClockSc a) #

type TQwtAnalogClockSc a = TQwtAnalogClock (CQwtAnalogClockSc a) #

data CQwtAnalogClockSc a #

qCastList_QwtAnalogClock :: QqCastList_QwtAnalogClock a r => a -> r #

withQwtAnalogClockResult :: IO (Ptr (TQwtAnalogClock a)) -> IO (QwtAnalogClock a) #

qwtAnalogClockFromPtr :: Ptr (TQwtAnalogClock a) -> IO (QwtAnalogClock a) #

qwtAnalogClockAddFinalizer :: QwtAnalogClock a -> IO () #

type QwtCompass a = QwtDial (CQwtCompass a) #

type TQwtCompass a = TQwtDial (CQwtCompass a) #

data CQwtCompass a #

qCast_QwtCompass :: Object a -> IO (QwtCompass ()) #

type QwtCompassSc a = QwtCompass (CQwtCompassSc a) #

type TQwtCompassSc a = TQwtCompass (CQwtCompassSc a) #

data CQwtCompassSc a #

qCastList_QwtCompass :: QqCastList_QwtCompass a r => a -> r #

withQwtCompassResult :: IO (Ptr (TQwtCompass a)) -> IO (QwtCompass a) #

qwtCompassFromPtr :: Ptr (TQwtCompass a) -> IO (QwtCompass a) #

qwtCompassAddFinalizer :: QwtCompass a -> IO () #

type QwtDialSimpleNeedle a = QwtDialNeedle (CQwtDialSimpleNeedle a) #

type TQwtDialSimpleNeedle a = TQwtDialNeedle (CQwtDialSimpleNeedle a) #

data CQwtDialSimpleNeedle a #

qCast_QwtDialSimpleNeedle :: Object a -> IO (QwtDialSimpleNeedle ()) #

type QwtDialSimpleNeedleSc a = QwtDialSimpleNeedle (CQwtDialSimpleNeedleSc a) #

type TQwtDialSimpleNeedleSc a = TQwtDialSimpleNeedle (CQwtDialSimpleNeedleSc a) #

data CQwtDialSimpleNeedleSc a #

qCastList_QwtDialSimpleNeedle :: QqCastList_QwtDialSimpleNeedle a r => a -> r #

withQwtDialSimpleNeedleResult :: IO (Ptr (TQwtDialSimpleNeedle a)) -> IO (QwtDialSimpleNeedle a) #

type QwtCompassMagnetNeedle a = QwtDialNeedle (CQwtCompassMagnetNeedle a) #

type TQwtCompassMagnetNeedle a = TQwtDialNeedle (CQwtCompassMagnetNeedle a) #

data CQwtCompassMagnetNeedle a #

qCast_QwtCompassMagnetNeedle :: Object a -> IO (QwtCompassMagnetNeedle ()) #

type QwtCompassMagnetNeedleSc a = QwtCompassMagnetNeedle (CQwtCompassMagnetNeedleSc a) #

type TQwtCompassMagnetNeedleSc a = TQwtCompassMagnetNeedle (CQwtCompassMagnetNeedleSc a) #

data CQwtCompassMagnetNeedleSc a #

qCastList_QwtCompassMagnetNeedle :: QqCastList_QwtCompassMagnetNeedle a r => a -> r #

withQwtCompassMagnetNeedleResult :: IO (Ptr (TQwtCompassMagnetNeedle a)) -> IO (QwtCompassMagnetNeedle a) #

type QwtCompassWindArrow a = QwtDialNeedle (CQwtCompassWindArrow a) #

type TQwtCompassWindArrow a = TQwtDialNeedle (CQwtCompassWindArrow a) #

data CQwtCompassWindArrow a #

qCast_QwtCompassWindArrow :: Object a -> IO (QwtCompassWindArrow ()) #

type QwtCompassWindArrowSc a = QwtCompassWindArrow (CQwtCompassWindArrowSc a) #

type TQwtCompassWindArrowSc a = TQwtCompassWindArrow (CQwtCompassWindArrowSc a) #

data CQwtCompassWindArrowSc a #

qCastList_QwtCompassWindArrow :: QqCastList_QwtCompassWindArrow a r => a -> r #

withQwtCompassWindArrowResult :: IO (Ptr (TQwtCompassWindArrow a)) -> IO (QwtCompassWindArrow a) #

type QwtDateScaleEngine a = QwtLinearScaleEngine (CQwtDateScaleEngine a) #

type TQwtDateScaleEngine a = TQwtLinearScaleEngine (CQwtDateScaleEngine a) #

data CQwtDateScaleEngine a #

qCast_QwtDateScaleEngine :: Object a -> IO (QwtDateScaleEngine ()) #

type QwtDateScaleEngineSc a = QwtDateScaleEngine (CQwtDateScaleEngineSc a) #

type TQwtDateScaleEngineSc a = TQwtDateScaleEngine (CQwtDateScaleEngineSc a) #

data CQwtDateScaleEngineSc a #

qCastList_QwtDateScaleEngine :: QqCastList_QwtDateScaleEngine a r => a -> r #

withQwtDateScaleEngineResult :: IO (Ptr (TQwtDateScaleEngine a)) -> IO (QwtDateScaleEngine a) #

type QwtPlotMagnifier a = QwtMagnifier (CQwtPlotMagnifier a) #

type TQwtPlotMagnifier a = TQwtMagnifier (CQwtPlotMagnifier a) #

data CQwtPlotMagnifier a #

qCast_QwtPlotMagnifier :: Object a -> IO (QwtPlotMagnifier ()) #

type QwtPlotMagnifierSc a = QwtPlotMagnifier (CQwtPlotMagnifierSc a) #

type TQwtPlotMagnifierSc a = TQwtPlotMagnifier (CQwtPlotMagnifierSc a) #

data CQwtPlotMagnifierSc a #

qCastList_QwtPlotMagnifier :: QqCastList_QwtPlotMagnifier a r => a -> r #

withQwtPlotMagnifierResult :: IO (Ptr (TQwtPlotMagnifier a)) -> IO (QwtPlotMagnifier a) #

qwtPlotMagnifierFromPtr :: Ptr (TQwtPlotMagnifier a) -> IO (QwtPlotMagnifier a) #

qwtPlotMagnifierAddFinalizer :: QwtPlotMagnifier a -> IO () #

type QwtGraphic a = QwtNullPaintDevice (CQwtGraphic a) #

type TQwtGraphic a = TQwtNullPaintDevice (CQwtGraphic a) #

data CQwtGraphic a #

qCast_QwtGraphic :: Object a -> IO (QwtGraphic ()) #

type QwtGraphicSc a = QwtGraphic (CQwtGraphicSc a) #

type TQwtGraphicSc a = TQwtGraphic (CQwtGraphicSc a) #

data CQwtGraphicSc a #

qCastList_QwtGraphic :: QqCastList_QwtGraphic a r => a -> r #

withQwtGraphicResult :: IO (Ptr (TQwtGraphic a)) -> IO (QwtGraphic a) #

type QwtPlotPanner a = QwtPanner (CQwtPlotPanner a) #

type TQwtPlotPanner a = TQwtPanner (CQwtPlotPanner a) #

data CQwtPlotPanner a #

qCast_QwtPlotPanner :: Object a -> IO (QwtPlotPanner ()) #

type QwtPlotPannerSc a = QwtPlotPanner (CQwtPlotPannerSc a) #

type TQwtPlotPannerSc a = TQwtPlotPanner (CQwtPlotPannerSc a) #

data CQwtPlotPannerSc a #

qCastList_QwtPlotPanner :: QqCastList_QwtPlotPanner a r => a -> r #

withQwtPlotPannerResult :: IO (Ptr (TQwtPlotPanner a)) -> IO (QwtPlotPanner a) #

qwtPlotPannerFromPtr :: Ptr (TQwtPlotPanner a) -> IO (QwtPlotPanner a) #

qwtPlotPannerAddFinalizer :: QwtPlotPanner a -> IO () #

type QwtPickerTrackerMachine a = QwtPickerMachine (CQwtPickerTrackerMachine a) #

type TQwtPickerTrackerMachine a = TQwtPickerMachine (CQwtPickerTrackerMachine a) #

data CQwtPickerTrackerMachine a #

qCast_QwtPickerTrackerMachine :: Object a -> IO (QwtPickerTrackerMachine ()) #

type QwtPickerTrackerMachineSc a = QwtPickerTrackerMachine (CQwtPickerTrackerMachineSc a) #

type TQwtPickerTrackerMachineSc a = TQwtPickerTrackerMachine (CQwtPickerTrackerMachineSc a) #

data CQwtPickerTrackerMachineSc a #

qCastList_QwtPickerTrackerMachine :: QqCastList_QwtPickerTrackerMachine a r => a -> r #

withQwtPickerTrackerMachineResult :: IO (Ptr (TQwtPickerTrackerMachine a)) -> IO (QwtPickerTrackerMachine a) #

type QwtPickerClickRectMachine a = QwtPickerMachine (CQwtPickerClickRectMachine a) #

type TQwtPickerClickRectMachine a = TQwtPickerMachine (CQwtPickerClickRectMachine a) #

data CQwtPickerClickRectMachine a #

qCast_QwtPickerClickRectMachine :: Object a -> IO (QwtPickerClickRectMachine ()) #

type QwtPickerClickRectMachineSc a = QwtPickerClickRectMachine (CQwtPickerClickRectMachineSc a) #

type TQwtPickerClickRectMachineSc a = TQwtPickerClickRectMachine (CQwtPickerClickRectMachineSc a) #

data CQwtPickerClickRectMachineSc a #

qCastList_QwtPickerClickRectMachine :: QqCastList_QwtPickerClickRectMachine a r => a -> r #

withQwtPickerClickRectMachineResult :: IO (Ptr (TQwtPickerClickRectMachine a)) -> IO (QwtPickerClickRectMachine a) #

type QwtPickerDragLineMachine a = QwtPickerMachine (CQwtPickerDragLineMachine a) #

type TQwtPickerDragLineMachine a = TQwtPickerMachine (CQwtPickerDragLineMachine a) #

data CQwtPickerDragLineMachine a #

qCast_QwtPickerDragLineMachine :: Object a -> IO (QwtPickerDragLineMachine ()) #

type QwtPickerDragLineMachineSc a = QwtPickerDragLineMachine (CQwtPickerDragLineMachineSc a) #

type TQwtPickerDragLineMachineSc a = TQwtPickerDragLineMachine (CQwtPickerDragLineMachineSc a) #

data CQwtPickerDragLineMachineSc a #

qCastList_QwtPickerDragLineMachine :: QqCastList_QwtPickerDragLineMachine a r => a -> r #

withQwtPickerDragLineMachineResult :: IO (Ptr (TQwtPickerDragLineMachine a)) -> IO (QwtPickerDragLineMachine a) #

type QwtPickerDragPointMachine a = QwtPickerMachine (CQwtPickerDragPointMachine a) #

type TQwtPickerDragPointMachine a = TQwtPickerMachine (CQwtPickerDragPointMachine a) #

data CQwtPickerDragPointMachine a #

qCast_QwtPickerDragPointMachine :: Object a -> IO (QwtPickerDragPointMachine ()) #

type QwtPickerDragPointMachineSc a = QwtPickerDragPointMachine (CQwtPickerDragPointMachineSc a) #

type TQwtPickerDragPointMachineSc a = TQwtPickerDragPointMachine (CQwtPickerDragPointMachineSc a) #

data CQwtPickerDragPointMachineSc a #

qCastList_QwtPickerDragPointMachine :: QqCastList_QwtPickerDragPointMachine a r => a -> r #

withQwtPickerDragPointMachineResult :: IO (Ptr (TQwtPickerDragPointMachine a)) -> IO (QwtPickerDragPointMachine a) #

type QwtPickerDragRectMachine a = QwtPickerMachine (CQwtPickerDragRectMachine a) #

type TQwtPickerDragRectMachine a = TQwtPickerMachine (CQwtPickerDragRectMachine a) #

data CQwtPickerDragRectMachine a #

qCast_QwtPickerDragRectMachine :: Object a -> IO (QwtPickerDragRectMachine ()) #

type QwtPickerDragRectMachineSc a = QwtPickerDragRectMachine (CQwtPickerDragRectMachineSc a) #

type TQwtPickerDragRectMachineSc a = TQwtPickerDragRectMachine (CQwtPickerDragRectMachineSc a) #

data CQwtPickerDragRectMachineSc a #

qCastList_QwtPickerDragRectMachine :: QqCastList_QwtPickerDragRectMachine a r => a -> r #

withQwtPickerDragRectMachineResult :: IO (Ptr (TQwtPickerDragRectMachine a)) -> IO (QwtPickerDragRectMachine a) #

type QwtPickerPolygonMachine a = QwtPickerMachine (CQwtPickerPolygonMachine a) #

type TQwtPickerPolygonMachine a = TQwtPickerMachine (CQwtPickerPolygonMachine a) #

data CQwtPickerPolygonMachine a #

qCast_QwtPickerPolygonMachine :: Object a -> IO (QwtPickerPolygonMachine ()) #

type QwtPickerPolygonMachineSc a = QwtPickerPolygonMachine (CQwtPickerPolygonMachineSc a) #

type TQwtPickerPolygonMachineSc a = TQwtPickerPolygonMachine (CQwtPickerPolygonMachineSc a) #

data CQwtPickerPolygonMachineSc a #

qCastList_QwtPickerPolygonMachine :: QqCastList_QwtPickerPolygonMachine a r => a -> r #

withQwtPickerPolygonMachineResult :: IO (Ptr (TQwtPickerPolygonMachine a)) -> IO (QwtPickerPolygonMachine a) #

type QwtPickerClickPointMachine a = QwtPickerMachine (CQwtPickerClickPointMachine a) #

type TQwtPickerClickPointMachine a = TQwtPickerMachine (CQwtPickerClickPointMachine a) #

data CQwtPickerClickPointMachine a #

qCast_QwtPickerClickPointMachine :: Object a -> IO (QwtPickerClickPointMachine ()) #

type QwtPickerClickPointMachineSc a = QwtPickerClickPointMachine (CQwtPickerClickPointMachineSc a) #

type TQwtPickerClickPointMachineSc a = TQwtPickerClickPointMachine (CQwtPickerClickPointMachineSc a) #

data CQwtPickerClickPointMachineSc a #

qCastList_QwtPickerClickPointMachine :: QqCastList_QwtPickerClickPointMachine a r => a -> r #

withQwtPickerClickPointMachineResult :: IO (Ptr (TQwtPickerClickPointMachine a)) -> IO (QwtPickerClickPointMachine a) #

type QwtPlotMultiBarChart a = QwtPlotAbstractBarChart (CQwtPlotMultiBarChart a) #

type TQwtPlotMultiBarChart a = TQwtPlotAbstractBarChart (CQwtPlotMultiBarChart a) #

data CQwtPlotMultiBarChart a #

qCast_QwtPlotMultiBarChart :: Object a -> IO (QwtPlotMultiBarChart ()) #

type QwtPlotMultiBarChartSc a = QwtPlotMultiBarChart (CQwtPlotMultiBarChartSc a) #

type TQwtPlotMultiBarChartSc a = TQwtPlotMultiBarChart (CQwtPlotMultiBarChartSc a) #

data CQwtPlotMultiBarChartSc a #

qCastList_QwtPlotMultiBarChart :: QqCastList_QwtPlotMultiBarChart a r => a -> r #

withQwtPlotMultiBarChartResult :: IO (Ptr (TQwtPlotMultiBarChart a)) -> IO (QwtPlotMultiBarChart a) #

type QwtPlotBarChart a = QwtPlotAbstractBarChart (CQwtPlotBarChart a) #

type TQwtPlotBarChart a = TQwtPlotAbstractBarChart (CQwtPlotBarChart a) #

data CQwtPlotBarChart a #

qCast_QwtPlotBarChart :: Object a -> IO (QwtPlotBarChart ()) #

type QwtPlotBarChartSc a = QwtPlotBarChart (CQwtPlotBarChartSc a) #

type TQwtPlotBarChartSc a = TQwtPlotBarChart (CQwtPlotBarChartSc a) #

data CQwtPlotBarChartSc a #

qCastList_QwtPlotBarChart :: QqCastList_QwtPlotBarChart a r => a -> r #

withQwtPlotBarChartResult :: IO (Ptr (TQwtPlotBarChart a)) -> IO (QwtPlotBarChart a) #

type QwtPlotZoneItem a = QwtPlotItem (CQwtPlotZoneItem a) #

type TQwtPlotZoneItem a = TQwtPlotItem (CQwtPlotZoneItem a) #

data CQwtPlotZoneItem a #

qCast_QwtPlotZoneItem :: Object a -> IO (QwtPlotZoneItem ()) #

type QwtPlotZoneItemSc a = QwtPlotZoneItem (CQwtPlotZoneItemSc a) #

type TQwtPlotZoneItemSc a = TQwtPlotZoneItem (CQwtPlotZoneItemSc a) #

data CQwtPlotZoneItemSc a #

qCastList_QwtPlotZoneItem :: QqCastList_QwtPlotZoneItem a r => a -> r #

withQwtPlotZoneItemResult :: IO (Ptr (TQwtPlotZoneItem a)) -> IO (QwtPlotZoneItem a) #

type QwtPlotSvgItem a = QwtPlotItem (CQwtPlotSvgItem a) #

type TQwtPlotSvgItem a = TQwtPlotItem (CQwtPlotSvgItem a) #

data CQwtPlotSvgItem a #

qCast_QwtPlotSvgItem :: Object a -> IO (QwtPlotSvgItem ()) #

type QwtPlotSvgItemSc a = QwtPlotSvgItem (CQwtPlotSvgItemSc a) #

type TQwtPlotSvgItemSc a = TQwtPlotSvgItem (CQwtPlotSvgItemSc a) #

data CQwtPlotSvgItemSc a #

qCastList_QwtPlotSvgItem :: QqCastList_QwtPlotSvgItem a r => a -> r #

withQwtPlotSvgItemResult :: IO (Ptr (TQwtPlotSvgItem a)) -> IO (QwtPlotSvgItem a) #

type QwtPlotScaleItem a = QwtPlotItem (CQwtPlotScaleItem a) #

type TQwtPlotScaleItem a = TQwtPlotItem (CQwtPlotScaleItem a) #

data CQwtPlotScaleItem a #

qCast_QwtPlotScaleItem :: Object a -> IO (QwtPlotScaleItem ()) #

type QwtPlotScaleItemSc a = QwtPlotScaleItem (CQwtPlotScaleItemSc a) #

type TQwtPlotScaleItemSc a = TQwtPlotScaleItem (CQwtPlotScaleItemSc a) #

data CQwtPlotScaleItemSc a #

qCastList_QwtPlotScaleItem :: QqCastList_QwtPlotScaleItem a r => a -> r #

withQwtPlotScaleItemResult :: IO (Ptr (TQwtPlotScaleItem a)) -> IO (QwtPlotScaleItem a) #

type QwtPlotShapeItem a = QwtPlotItem (CQwtPlotShapeItem a) #

type TQwtPlotShapeItem a = TQwtPlotItem (CQwtPlotShapeItem a) #

data CQwtPlotShapeItem a #

qCast_QwtPlotShapeItem :: Object a -> IO (QwtPlotShapeItem ()) #

type QwtPlotShapeItemSc a = QwtPlotShapeItem (CQwtPlotShapeItemSc a) #

type TQwtPlotShapeItemSc a = TQwtPlotShapeItem (CQwtPlotShapeItemSc a) #

data CQwtPlotShapeItemSc a #

qCastList_QwtPlotShapeItem :: QqCastList_QwtPlotShapeItem a r => a -> r #

withQwtPlotShapeItemResult :: IO (Ptr (TQwtPlotShapeItem a)) -> IO (QwtPlotShapeItem a) #

type QwtPlotLegendItem a = QwtPlotItem (CQwtPlotLegendItem a) #

type TQwtPlotLegendItem a = TQwtPlotItem (CQwtPlotLegendItem a) #

data CQwtPlotLegendItem a #

qCast_QwtPlotLegendItem :: Object a -> IO (QwtPlotLegendItem ()) #

type QwtPlotLegendItemSc a = QwtPlotLegendItem (CQwtPlotLegendItemSc a) #

type TQwtPlotLegendItemSc a = TQwtPlotLegendItem (CQwtPlotLegendItemSc a) #

data CQwtPlotLegendItemSc a #

qCastList_QwtPlotLegendItem :: QqCastList_QwtPlotLegendItem a r => a -> r #

withQwtPlotLegendItemResult :: IO (Ptr (TQwtPlotLegendItem a)) -> IO (QwtPlotLegendItem a) #

type QwtPlotTextLabel a = QwtPlotItem (CQwtPlotTextLabel a) #

type TQwtPlotTextLabel a = TQwtPlotItem (CQwtPlotTextLabel a) #

data CQwtPlotTextLabel a #

qCast_QwtPlotTextLabel :: Object a -> IO (QwtPlotTextLabel ()) #

type QwtPlotTextLabelSc a = QwtPlotTextLabel (CQwtPlotTextLabelSc a) #

type TQwtPlotTextLabelSc a = TQwtPlotTextLabel (CQwtPlotTextLabelSc a) #

data CQwtPlotTextLabelSc a #

qCastList_QwtPlotTextLabel :: QqCastList_QwtPlotTextLabel a r => a -> r #

withQwtPlotTextLabelResult :: IO (Ptr (TQwtPlotTextLabel a)) -> IO (QwtPlotTextLabel a) #

type QwtPlotMarker a = QwtPlotItem (CQwtPlotMarker a) #

type TQwtPlotMarker a = TQwtPlotItem (CQwtPlotMarker a) #

data CQwtPlotMarker a #

qCast_QwtPlotMarker :: Object a -> IO (QwtPlotMarker ()) #

type QwtPlotMarkerSc a = QwtPlotMarker (CQwtPlotMarkerSc a) #

type TQwtPlotMarkerSc a = TQwtPlotMarker (CQwtPlotMarkerSc a) #

data CQwtPlotMarkerSc a #

qCastList_QwtPlotMarker :: QqCastList_QwtPlotMarker a r => a -> r #

withQwtPlotMarkerResult :: IO (Ptr (TQwtPlotMarker a)) -> IO (QwtPlotMarker a) #

type QwtPlotGrid a = QwtPlotItem (CQwtPlotGrid a) #

type TQwtPlotGrid a = TQwtPlotItem (CQwtPlotGrid a) #

data CQwtPlotGrid a #

qCast_QwtPlotGrid :: Object a -> IO (QwtPlotGrid ()) #

type QwtPlotGridSc a = QwtPlotGrid (CQwtPlotGridSc a) #

type TQwtPlotGridSc a = TQwtPlotGrid (CQwtPlotGridSc a) #

data CQwtPlotGridSc a #

qCastList_QwtPlotGrid :: QqCastList_QwtPlotGrid a r => a -> r #

withQwtPlotGridResult :: IO (Ptr (TQwtPlotGrid a)) -> IO (QwtPlotGrid a) #

type QwtPlotZoomer a = QwtPlotPicker (CQwtPlotZoomer a) #

type TQwtPlotZoomer a = TQwtPlotPicker (CQwtPlotZoomer a) #

data CQwtPlotZoomer a #

qCast_QwtPlotZoomer :: Object a -> IO (QwtPlotZoomer ()) #

type QwtPlotZoomerSc a = QwtPlotZoomer (CQwtPlotZoomerSc a) #

type TQwtPlotZoomerSc a = TQwtPlotZoomer (CQwtPlotZoomerSc a) #

data CQwtPlotZoomerSc a #

qCastList_QwtPlotZoomer :: QqCastList_QwtPlotZoomer a r => a -> r #

withQwtPlotZoomerResult :: IO (Ptr (TQwtPlotZoomer a)) -> IO (QwtPlotZoomer a) #

qwtPlotZoomerFromPtr :: Ptr (TQwtPlotZoomer a) -> IO (QwtPlotZoomer a) #

qwtPlotZoomerAddFinalizer :: QwtPlotZoomer a -> IO () #

type QwtPlotSpectrogram a = QwtPlotRasterItem (CQwtPlotSpectrogram a) #

type TQwtPlotSpectrogram a = TQwtPlotRasterItem (CQwtPlotSpectrogram a) #

data CQwtPlotSpectrogram a #

qCast_QwtPlotSpectrogram :: Object a -> IO (QwtPlotSpectrogram ()) #

type QwtPlotSpectrogramSc a = QwtPlotSpectrogram (CQwtPlotSpectrogramSc a) #

type TQwtPlotSpectrogramSc a = TQwtPlotSpectrogram (CQwtPlotSpectrogramSc a) #

data CQwtPlotSpectrogramSc a #

qCastList_QwtPlotSpectrogram :: QqCastList_QwtPlotSpectrogram a r => a -> r #

withQwtPlotSpectrogramResult :: IO (Ptr (TQwtPlotSpectrogram a)) -> IO (QwtPlotSpectrogram a) #

type QwtPlotIntervalCurve a = QwtPlotSeriesItem (CQwtPlotIntervalCurve a) #

type TQwtPlotIntervalCurve a = TQwtPlotSeriesItem (CQwtPlotIntervalCurve a) #

data CQwtPlotIntervalCurve a #

qCast_QwtPlotIntervalCurve :: Object a -> IO (QwtPlotIntervalCurve ()) #

type QwtPlotIntervalCurveSc a = QwtPlotIntervalCurve (CQwtPlotIntervalCurveSc a) #

type TQwtPlotIntervalCurveSc a = TQwtPlotIntervalCurve (CQwtPlotIntervalCurveSc a) #

data CQwtPlotIntervalCurveSc a #

qCastList_QwtPlotIntervalCurve :: QqCastList_QwtPlotIntervalCurve a r => a -> r #

withQwtPlotIntervalCurveResult :: IO (Ptr (TQwtPlotIntervalCurve a)) -> IO (QwtPlotIntervalCurve a) #

type QwtPlotCurve a = QwtPlotSeriesItem (CQwtPlotCurve a) #

type TQwtPlotCurve a = TQwtPlotSeriesItem (CQwtPlotCurve a) #

data CQwtPlotCurve a #

qCast_QwtPlotCurve :: Object a -> IO (QwtPlotCurve ()) #

type QwtPlotCurveSc a = QwtPlotCurve (CQwtPlotCurveSc a) #

type TQwtPlotCurveSc a = TQwtPlotCurve (CQwtPlotCurveSc a) #

data CQwtPlotCurveSc a #

qCastList_QwtPlotCurve :: QqCastList_QwtPlotCurve a r => a -> r #

withQwtPlotCurveResult :: IO (Ptr (TQwtPlotCurve a)) -> IO (QwtPlotCurve a) #

type QwtPlotHistogram a = QwtPlotSeriesItem (CQwtPlotHistogram a) #

type TQwtPlotHistogram a = TQwtPlotSeriesItem (CQwtPlotHistogram a) #

data CQwtPlotHistogram a #

qCast_QwtPlotHistogram :: Object a -> IO (QwtPlotHistogram ()) #

type QwtPlotHistogramSc a = QwtPlotHistogram (CQwtPlotHistogramSc a) #

type TQwtPlotHistogramSc a = TQwtPlotHistogram (CQwtPlotHistogramSc a) #

data CQwtPlotHistogramSc a #

qCastList_QwtPlotHistogram :: QqCastList_QwtPlotHistogram a r => a -> r #

withQwtPlotHistogramResult :: IO (Ptr (TQwtPlotHistogram a)) -> IO (QwtPlotHistogram a) #

type QwtPlotTradingCurve a = QwtPlotSeriesItem (CQwtPlotTradingCurve a) #

type TQwtPlotTradingCurve a = TQwtPlotSeriesItem (CQwtPlotTradingCurve a) #

data CQwtPlotTradingCurve a #

qCast_QwtPlotTradingCurve :: Object a -> IO (QwtPlotTradingCurve ()) #

type QwtPlotTradingCurveSc a = QwtPlotTradingCurve (CQwtPlotTradingCurveSc a) #

type TQwtPlotTradingCurveSc a = TQwtPlotTradingCurve (CQwtPlotTradingCurveSc a) #

data CQwtPlotTradingCurveSc a #

qCastList_QwtPlotTradingCurve :: QqCastList_QwtPlotTradingCurve a r => a -> r #

withQwtPlotTradingCurveResult :: IO (Ptr (TQwtPlotTradingCurve a)) -> IO (QwtPlotTradingCurve a) #

type QwtPlotSpectroCurve a = QwtPlotSeriesItem (CQwtPlotSpectroCurve a) #

type TQwtPlotSpectroCurve a = TQwtPlotSeriesItem (CQwtPlotSpectroCurve a) #

data CQwtPlotSpectroCurve a #

qCast_QwtPlotSpectroCurve :: Object a -> IO (QwtPlotSpectroCurve ()) #

type QwtPlotSpectroCurveSc a = QwtPlotSpectroCurve (CQwtPlotSpectroCurveSc a) #

type TQwtPlotSpectroCurveSc a = TQwtPlotSpectroCurve (CQwtPlotSpectroCurveSc a) #

data CQwtPlotSpectroCurveSc a #

qCastList_QwtPlotSpectroCurve :: QqCastList_QwtPlotSpectroCurve a r => a -> r #

withQwtPlotSpectroCurveResult :: IO (Ptr (TQwtPlotSpectroCurve a)) -> IO (QwtPlotSpectroCurve a) #

type QwtMatrixRasterData a = QwtRasterData (CQwtMatrixRasterData a) #

type TQwtMatrixRasterData a = TQwtRasterData (CQwtMatrixRasterData a) #

data CQwtMatrixRasterData a #

qCast_QwtMatrixRasterData :: Object a -> IO (QwtMatrixRasterData ()) #

type QwtMatrixRasterDataSc a = QwtMatrixRasterData (CQwtMatrixRasterDataSc a) #

type TQwtMatrixRasterDataSc a = TQwtMatrixRasterData (CQwtMatrixRasterDataSc a) #

data CQwtMatrixRasterDataSc a #

qCastList_QwtMatrixRasterData :: QqCastList_QwtMatrixRasterData a r => a -> r #

withQwtMatrixRasterDataResult :: IO (Ptr (TQwtMatrixRasterData a)) -> IO (QwtMatrixRasterData a) #

type QwtCompassScaleDraw a = QwtRoundScaleDraw (CQwtCompassScaleDraw a) #

type TQwtCompassScaleDraw a = TQwtRoundScaleDraw (CQwtCompassScaleDraw a) #

data CQwtCompassScaleDraw a #

qCast_QwtCompassScaleDraw :: Object a -> IO (QwtCompassScaleDraw ()) #

type QwtCompassScaleDrawSc a = QwtCompassScaleDraw (CQwtCompassScaleDrawSc a) #

type TQwtCompassScaleDrawSc a = TQwtCompassScaleDraw (CQwtCompassScaleDrawSc a) #

data CQwtCompassScaleDrawSc a #

qCastList_QwtCompassScaleDraw :: QqCastList_QwtCompassScaleDraw a r => a -> r #

withQwtCompassScaleDrawResult :: IO (Ptr (TQwtCompassScaleDraw a)) -> IO (QwtCompassScaleDraw a) #

type QwtDateScaleDraw a = QwtScaleDraw (CQwtDateScaleDraw a) #

type TQwtDateScaleDraw a = TQwtScaleDraw (CQwtDateScaleDraw a) #

data CQwtDateScaleDraw a #

qCast_QwtDateScaleDraw :: Object a -> IO (QwtDateScaleDraw ()) #

type QwtDateScaleDrawSc a = QwtDateScaleDraw (CQwtDateScaleDrawSc a) #

type TQwtDateScaleDrawSc a = TQwtDateScaleDraw (CQwtDateScaleDrawSc a) #

data CQwtDateScaleDrawSc a #

qCastList_QwtDateScaleDraw :: QqCastList_QwtDateScaleDraw a r => a -> r #

withQwtDateScaleDrawResult :: IO (Ptr (TQwtDateScaleDraw a)) -> IO (QwtDateScaleDraw a) #

type QwtLogScaleEngine a = QwtScaleEngine (CQwtLogScaleEngine a) #

type TQwtLogScaleEngine a = TQwtScaleEngine (CQwtLogScaleEngine a) #

data CQwtLogScaleEngine a #

qCast_QwtLogScaleEngine :: Object a -> IO (QwtLogScaleEngine ()) #

type QwtLogScaleEngineSc a = QwtLogScaleEngine (CQwtLogScaleEngineSc a) #

type TQwtLogScaleEngineSc a = TQwtLogScaleEngine (CQwtLogScaleEngineSc a) #

data CQwtLogScaleEngineSc a #

qCastList_QwtLogScaleEngine :: QqCastList_QwtLogScaleEngine a r => a -> r #

withQwtLogScaleEngineResult :: IO (Ptr (TQwtLogScaleEngine a)) -> IO (QwtLogScaleEngine a) #

type QwtRichTextEngine a = QwtTextEngine (CQwtRichTextEngine a) #

type TQwtRichTextEngine a = TQwtTextEngine (CQwtRichTextEngine a) #

data CQwtRichTextEngine a #

qCast_QwtRichTextEngine :: Object a -> IO (QwtRichTextEngine ()) #

type QwtRichTextEngineSc a = QwtRichTextEngine (CQwtRichTextEngineSc a) #

type TQwtRichTextEngineSc a = TQwtRichTextEngine (CQwtRichTextEngineSc a) #

data CQwtRichTextEngineSc a #

qCastList_QwtRichTextEngine :: QqCastList_QwtRichTextEngine a r => a -> r #

withQwtRichTextEngineResult :: IO (Ptr (TQwtRichTextEngine a)) -> IO (QwtRichTextEngine a) #

type QwtPlainTextEngine a = QwtTextEngine (CQwtPlainTextEngine a) #

type TQwtPlainTextEngine a = TQwtTextEngine (CQwtPlainTextEngine a) #

data CQwtPlainTextEngine a #

qCast_QwtPlainTextEngine :: Object a -> IO (QwtPlainTextEngine ()) #

type QwtPlainTextEngineSc a = QwtPlainTextEngine (CQwtPlainTextEngineSc a) #

type TQwtPlainTextEngineSc a = TQwtPlainTextEngine (CQwtPlainTextEngineSc a) #

data CQwtPlainTextEngineSc a #

qCastList_QwtPlainTextEngine :: QqCastList_QwtPlainTextEngine a r => a -> r #

withQwtPlainTextEngineResult :: IO (Ptr (TQwtPlainTextEngine a)) -> IO (QwtPlainTextEngine a) #

type QwtLegendLabel a = QwtTextLabel (CQwtLegendLabel a) #

type TQwtLegendLabel a = TQwtTextLabel (CQwtLegendLabel a) #

data CQwtLegendLabel a #

qCast_QwtLegendLabel :: Object a -> IO (QwtLegendLabel ()) #

type QwtLegendLabelSc a = QwtLegendLabel (CQwtLegendLabelSc a) #

type TQwtLegendLabelSc a = TQwtLegendLabel (CQwtLegendLabelSc a) #

data CQwtLegendLabelSc a #

qCastList_QwtLegendLabel :: QqCastList_QwtLegendLabel a r => a -> r #

withQwtLegendLabelResult :: IO (Ptr (TQwtLegendLabel a)) -> IO (QwtLegendLabel a) #

qwtLegendLabelFromPtr :: Ptr (TQwtLegendLabel a) -> IO (QwtLegendLabel a) #

qwtLegendLabelAddFinalizer :: QwtLegendLabel a -> IO () #

type QwtLogTransform a = QwtTransform (CQwtLogTransform a) #

type TQwtLogTransform a = TQwtTransform (CQwtLogTransform a) #

data CQwtLogTransform a #

qCast_QwtLogTransform :: Object a -> IO (QwtLogTransform ()) #

type QwtLogTransformSc a = QwtLogTransform (CQwtLogTransformSc a) #

type TQwtLogTransformSc a = TQwtLogTransform (CQwtLogTransformSc a) #

data CQwtLogTransformSc a #

qCastList_QwtLogTransform :: QqCastList_QwtLogTransform a r => a -> r #

withQwtLogTransformResult :: IO (Ptr (TQwtLogTransform a)) -> IO (QwtLogTransform a) #

type QwtNullTransform a = QwtTransform (CQwtNullTransform a) #

type TQwtNullTransform a = TQwtTransform (CQwtNullTransform a) #

data CQwtNullTransform a #

qCast_QwtNullTransform :: Object a -> IO (QwtNullTransform ()) #

type QwtNullTransformSc a = QwtNullTransform (CQwtNullTransformSc a) #

type TQwtNullTransformSc a = TQwtNullTransform (CQwtNullTransformSc a) #

data CQwtNullTransformSc a #

qCastList_QwtNullTransform :: QqCastList_QwtNullTransform a r => a -> r #

withQwtNullTransformResult :: IO (Ptr (TQwtNullTransform a)) -> IO (QwtNullTransform a) #

type QwtPowerTransform a = QwtTransform (CQwtPowerTransform a) #

type TQwtPowerTransform a = TQwtTransform (CQwtPowerTransform a) #

data CQwtPowerTransform a #

qCast_QwtPowerTransform :: Object a -> IO (QwtPowerTransform ()) #

type QwtPowerTransformSc a = QwtPowerTransform (CQwtPowerTransformSc a) #

type TQwtPowerTransformSc a = TQwtPowerTransform (CQwtPowerTransformSc a) #

data CQwtPowerTransformSc a #

qCastList_QwtPowerTransform :: QqCastList_QwtPowerTransform a r => a -> r #

withQwtPowerTransformResult :: IO (Ptr (TQwtPowerTransform a)) -> IO (QwtPowerTransform a) #

type QConstQwtSeriesDataQPointFPtr a = Object (CQConstQwtSeriesDataQPointFPtr a) #

type TQConstQwtSeriesDataQPointFPtr a = CQConstQwtSeriesDataQPointFPtr a #

data CQConstQwtSeriesDataQPointFPtr a #

withQConstQwtSeriesDataQPointFPtrResult :: IO (Ptr (TQConstQwtSeriesDataQPointFPtr a)) -> IO (QConstQwtSeriesDataQPointFPtr a) #

type QwtSeriesDataQPointF a = Object (CQwtSeriesDataQPointF a) #

type TQwtSeriesDataQPointF a = CQwtSeriesDataQPointF a #

data CQwtSeriesDataQPointF a #

withQwtSeriesDataQPointFResult :: IO (Ptr (TQwtSeriesDataQPointF a)) -> IO (QwtSeriesDataQPointF a) #

type QwtSeriesDataQwtIntervalSample a = Object (CQwtSeriesDataQwtIntervalSample a) #

type TQwtSeriesDataQwtIntervalSample a = CQwtSeriesDataQwtIntervalSample a #

data CQwtSeriesDataQwtIntervalSample a #

withQwtSeriesDataQwtIntervalSampleResult :: IO (Ptr (TQwtSeriesDataQwtIntervalSample a)) -> IO (QwtSeriesDataQwtIntervalSample a) #

type QwtSeriesDataQwtSetSample a = Object (CQwtSeriesDataQwtSetSample a) #

type TQwtSeriesDataQwtSetSample a = CQwtSeriesDataQwtSetSample a #

data CQwtSeriesDataQwtSetSample a #

withQwtSeriesDataQwtSetSampleResult :: IO (Ptr (TQwtSeriesDataQwtSetSample a)) -> IO (QwtSeriesDataQwtSetSample a) #

type QwtSeriesDataQwtPoint3D a = Object (CQwtSeriesDataQwtPoint3D a) #

type TQwtSeriesDataQwtPoint3D a = CQwtSeriesDataQwtPoint3D a #

data CQwtSeriesDataQwtPoint3D a #

withQwtSeriesDataQwtPoint3DResult :: IO (Ptr (TQwtSeriesDataQwtPoint3D a)) -> IO (QwtSeriesDataQwtPoint3D a) #

type QwtSeriesDataQwtOHLCSample a = Object (CQwtSeriesDataQwtOHLCSample a) #

type TQwtSeriesDataQwtOHLCSample a = CQwtSeriesDataQwtOHLCSample a #

data CQwtSeriesDataQwtOHLCSample a #

withQwtSeriesDataQwtOHLCSampleResult :: IO (Ptr (TQwtSeriesDataQwtOHLCSample a)) -> IO (QwtSeriesDataQwtOHLCSample a) #

qListFromQListQwtLegendDataPtr :: Ptr (TQListQwtLegendData ()) -> IO [QwtLegendData t0] #

withQListQwtLegendDataHResult :: [QwtLegendData t0] -> IO (Ptr (TQListQwtLegendData ())) #