QDoubleSpinBox.hs

{-# LANGUAGE FlexibleContexts, FlexibleInstances, ForeignFunctionInterface, MonoLocalBinds, MultiParamTypeClasses, ScopedTypeVariables, TypeSynonymInstances, UndecidableInstances #-}
---------- GENERATED FILE, EDITS WILL BE LOST ----------

module Graphics.UI.Qtah.Generated.Widgets.QDoubleSpinBox (
  castQDoubleSpinBoxToQAbstractSpinBox,
  castQAbstractSpinBoxToQDoubleSpinBox,
  castQDoubleSpinBoxToQWidget,
  castQWidgetToQDoubleSpinBox,
  castQDoubleSpinBoxToQObject,
  castQObjectToQDoubleSpinBox,
  QDoubleSpinBoxValue (..),
  QDoubleSpinBoxConstPtr (..),
  cleanText,
  decimals,
  maximum,
  minimum,
  prefix,
  singleStep,
  suffix,
  textFromValue,
  value,
  valueFromText,
  QDoubleSpinBoxPtr (..),
  setDecimals,
  setMaximum,
  setMinimum,
  setPrefix,
  setRange,
  setSingleStep,
  setSuffix,
  setValue,
  emitValueChangedDouble,
  emitValueChangedString,
  QDoubleSpinBoxConst (..),
  castQDoubleSpinBoxToConst,
  QDoubleSpinBox (..),
  castQDoubleSpinBoxToNonconst,
  new,
  newWithParent,
  QDoubleSpinBoxSuper (..),
  QDoubleSpinBoxSuperConst (..),
  ) where

import qualified Foreign as HoppyF
import qualified Foreign.C as HoppyFC
import qualified Foreign.Hoppy.Runtime as HoppyFHR
import qualified Graphics.UI.Qtah.Generated.Core.QObject as M94
import qualified Graphics.UI.Qtah.Generated.Core.QString as M142
import qualified Graphics.UI.Qtah.Generated.Widgets.QAbstractSpinBox as M366
import qualified Graphics.UI.Qtah.Generated.Widgets.QWidget as M506
import Prelude (($), (.), (=<<), (==), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QDoubleSpinBox_new" new' ::  HoppyP.IO (HoppyF.Ptr QDoubleSpinBox)
foreign import ccall "genpop__QDoubleSpinBox_newWithParent" newWithParent' ::  HoppyF.Ptr M506.QWidget -> HoppyP.IO (HoppyF.Ptr QDoubleSpinBox)
foreign import ccall "genpop__QDoubleSpinBox_cleanText" cleanText' ::  HoppyF.Ptr QDoubleSpinBoxConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QDoubleSpinBox_decimals" decimals' ::  HoppyF.Ptr QDoubleSpinBoxConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QDoubleSpinBox_setDecimals" setDecimals' ::  HoppyF.Ptr QDoubleSpinBox -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QDoubleSpinBox_maximum" maximum' ::  HoppyF.Ptr QDoubleSpinBoxConst -> HoppyP.IO HoppyFC.CDouble
foreign import ccall "genpop__QDoubleSpinBox_setMaximum" setMaximum' ::  HoppyF.Ptr QDoubleSpinBox -> HoppyFC.CDouble -> HoppyP.IO ()
foreign import ccall "genpop__QDoubleSpinBox_minimum" minimum' ::  HoppyF.Ptr QDoubleSpinBoxConst -> HoppyP.IO HoppyFC.CDouble
foreign import ccall "genpop__QDoubleSpinBox_setMinimum" setMinimum' ::  HoppyF.Ptr QDoubleSpinBox -> HoppyFC.CDouble -> HoppyP.IO ()
foreign import ccall "genpop__QDoubleSpinBox_prefix" prefix' ::  HoppyF.Ptr QDoubleSpinBoxConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QDoubleSpinBox_setPrefix" setPrefix' ::  HoppyF.Ptr QDoubleSpinBox -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QDoubleSpinBox_setRange" setRange' ::  HoppyF.Ptr QDoubleSpinBox -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyP.IO ()
foreign import ccall "genpop__QDoubleSpinBox_singleStep" singleStep' ::  HoppyF.Ptr QDoubleSpinBoxConst -> HoppyP.IO HoppyFC.CDouble
foreign import ccall "genpop__QDoubleSpinBox_setSingleStep" setSingleStep' ::  HoppyF.Ptr QDoubleSpinBox -> HoppyFC.CDouble -> HoppyP.IO ()
foreign import ccall "genpop__QDoubleSpinBox_suffix" suffix' ::  HoppyF.Ptr QDoubleSpinBoxConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QDoubleSpinBox_setSuffix" setSuffix' ::  HoppyF.Ptr QDoubleSpinBox -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QDoubleSpinBox_textFromValue" textFromValue' ::  HoppyF.Ptr QDoubleSpinBoxConst -> HoppyFC.CDouble -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QDoubleSpinBox_value" value' ::  HoppyF.Ptr QDoubleSpinBoxConst -> HoppyP.IO HoppyFC.CDouble
foreign import ccall "genpop__QDoubleSpinBox_setValue" setValue' ::  HoppyF.Ptr QDoubleSpinBox -> HoppyFC.CDouble -> HoppyP.IO ()
foreign import ccall "genpop__QDoubleSpinBox_valueFromText" valueFromText' ::  HoppyF.Ptr QDoubleSpinBoxConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CDouble
foreign import ccall "genpop__QDoubleSpinBox_emitValueChangedDouble" emitValueChangedDouble' ::  HoppyF.Ptr QDoubleSpinBox -> HoppyFC.CDouble -> HoppyP.IO ()
foreign import ccall "genpop__QDoubleSpinBox_emitValueChangedString" emitValueChangedString' ::  HoppyF.Ptr QDoubleSpinBox -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "gencast__QDoubleSpinBox__QAbstractSpinBox" castQDoubleSpinBoxToQAbstractSpinBox :: HoppyF.Ptr QDoubleSpinBoxConst -> HoppyF.Ptr M366.QAbstractSpinBoxConst
foreign import ccall "gencast__QAbstractSpinBox__QDoubleSpinBox" castQAbstractSpinBoxToQDoubleSpinBox :: HoppyF.Ptr M366.QAbstractSpinBoxConst -> HoppyF.Ptr QDoubleSpinBoxConst
foreign import ccall "gencast__QDoubleSpinBox__QWidget" castQDoubleSpinBoxToQWidget :: HoppyF.Ptr QDoubleSpinBoxConst -> HoppyF.Ptr M506.QWidgetConst
foreign import ccall "gencast__QWidget__QDoubleSpinBox" castQWidgetToQDoubleSpinBox :: HoppyF.Ptr M506.QWidgetConst -> HoppyF.Ptr QDoubleSpinBoxConst
foreign import ccall "gencast__QDoubleSpinBox__QObject" castQDoubleSpinBoxToQObject :: HoppyF.Ptr QDoubleSpinBoxConst -> HoppyF.Ptr M94.QObjectConst
foreign import ccall "gencast__QObject__QDoubleSpinBox" castQObjectToQDoubleSpinBox :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr QDoubleSpinBoxConst
foreign import ccall "gendel__QDoubleSpinBox" delete'QDoubleSpinBox :: HoppyF.Ptr QDoubleSpinBoxConst -> HoppyP.IO ()
foreign import ccall "&gendel__QDoubleSpinBox" deletePtr'QDoubleSpinBox :: HoppyF.FunPtr (HoppyF.Ptr QDoubleSpinBoxConst -> HoppyP.IO ())

class QDoubleSpinBoxValue a where
  withQDoubleSpinBoxPtr :: a -> (QDoubleSpinBoxConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QDoubleSpinBoxConstPtr a => QDoubleSpinBoxValue a where
  withQDoubleSpinBoxPtr = HoppyP.flip ($) . toQDoubleSpinBoxConst

class (M366.QAbstractSpinBoxConstPtr this) => QDoubleSpinBoxConstPtr this where
  toQDoubleSpinBoxConst :: this -> QDoubleSpinBoxConst

cleanText :: (QDoubleSpinBoxValue this) => (this) {- ^ this -} -> (HoppyP.IO QtahP.String)
cleanText arg'1 =
  withQDoubleSpinBoxPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (cleanText' arg'1')

decimals :: (QDoubleSpinBoxValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Int)
decimals arg'1 =
  withQDoubleSpinBoxPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (decimals' arg'1')

maximum :: (QDoubleSpinBoxValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Double)
maximum arg'1 =
  withQDoubleSpinBoxPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) =<<
  (maximum' arg'1')

minimum :: (QDoubleSpinBoxValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Double)
minimum arg'1 =
  withQDoubleSpinBoxPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) =<<
  (minimum' arg'1')

prefix :: (QDoubleSpinBoxValue this) => (this) {- ^ this -} -> (HoppyP.IO QtahP.String)
prefix arg'1 =
  withQDoubleSpinBoxPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (prefix' arg'1')

singleStep :: (QDoubleSpinBoxValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Double)
singleStep arg'1 =
  withQDoubleSpinBoxPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) =<<
  (singleStep' arg'1')

suffix :: (QDoubleSpinBoxValue this) => (this) {- ^ this -} -> (HoppyP.IO QtahP.String)
suffix arg'1 =
  withQDoubleSpinBoxPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (suffix' arg'1')

textFromValue :: (QDoubleSpinBoxValue this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.IO QtahP.String)
textFromValue arg'1 arg'2 =
  withQDoubleSpinBoxPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (textFromValue' arg'1' arg'2')

value :: (QDoubleSpinBoxValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Double)
value arg'1 =
  withQDoubleSpinBoxPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) =<<
  (value' arg'1')

valueFromText :: (QDoubleSpinBoxValue this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Double)
valueFromText arg'1 arg'2 =
  withQDoubleSpinBoxPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) =<<
  (valueFromText' arg'1' arg'2')

class (QDoubleSpinBoxConstPtr this, M366.QAbstractSpinBoxPtr this) => QDoubleSpinBoxPtr this where
  toQDoubleSpinBox :: this -> QDoubleSpinBox

setDecimals :: (QDoubleSpinBoxPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO ())
setDecimals arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQDoubleSpinBox arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (setDecimals' arg'1' arg'2')

setMaximum :: (QDoubleSpinBoxPtr this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.IO ())
setMaximum arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQDoubleSpinBox arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (setMaximum' arg'1' arg'2')

setMinimum :: (QDoubleSpinBoxPtr this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.IO ())
setMinimum arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQDoubleSpinBox arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (setMinimum' arg'1' arg'2')

setPrefix :: (QDoubleSpinBoxPtr this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setPrefix arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQDoubleSpinBox arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setPrefix' arg'1' arg'2')

setRange :: (QDoubleSpinBoxPtr this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.IO ())
setRange arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQDoubleSpinBox arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'3 >>= \arg'3' ->
  (setRange' arg'1' arg'2' arg'3')

setSingleStep :: (QDoubleSpinBoxPtr this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.IO ())
setSingleStep arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQDoubleSpinBox arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (setSingleStep' arg'1' arg'2')

setSuffix :: (QDoubleSpinBoxPtr this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setSuffix arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQDoubleSpinBox arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setSuffix' arg'1' arg'2')

setValue :: (QDoubleSpinBoxPtr this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.IO ())
setValue arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQDoubleSpinBox arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (setValue' arg'1' arg'2')

emitValueChangedDouble :: (QDoubleSpinBoxPtr this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.IO ())
emitValueChangedDouble arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQDoubleSpinBox arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (emitValueChangedDouble' arg'1' arg'2')

emitValueChangedString :: (QDoubleSpinBoxPtr this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
emitValueChangedString arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQDoubleSpinBox arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (emitValueChangedString' arg'1' arg'2')

data QDoubleSpinBoxConst =
    QDoubleSpinBoxConst (HoppyF.Ptr QDoubleSpinBoxConst)
  | QDoubleSpinBoxConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QDoubleSpinBoxConst)
  deriving (HoppyP.Show)

instance HoppyP.Eq QDoubleSpinBoxConst where
  x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y

instance HoppyP.Ord QDoubleSpinBoxConst where
  compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)

castQDoubleSpinBoxToConst :: QDoubleSpinBox -> QDoubleSpinBoxConst
castQDoubleSpinBoxToConst (QDoubleSpinBox ptr') = QDoubleSpinBoxConst $ HoppyF.castPtr ptr'
castQDoubleSpinBoxToConst (QDoubleSpinBoxGc fptr' ptr') = QDoubleSpinBoxConstGc fptr' $ HoppyF.castPtr ptr'

instance HoppyFHR.CppPtr QDoubleSpinBoxConst where
  nullptr = QDoubleSpinBoxConst HoppyF.nullPtr
  
  withCppPtr (QDoubleSpinBoxConst ptr') f' = f' ptr'
  withCppPtr (QDoubleSpinBoxConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
  
  toPtr (QDoubleSpinBoxConst ptr') = ptr'
  toPtr (QDoubleSpinBoxConstGc _ ptr') = ptr'
  
  touchCppPtr (QDoubleSpinBoxConst _) = HoppyP.return ()
  touchCppPtr (QDoubleSpinBoxConstGc fptr' _) = HoppyF.touchForeignPtr fptr'

instance HoppyFHR.Deletable QDoubleSpinBoxConst where
  delete (QDoubleSpinBoxConst ptr') = delete'QDoubleSpinBox ptr'
  delete (QDoubleSpinBoxConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "QDoubleSpinBoxConst", " object."]
  
  toGc this'@(QDoubleSpinBoxConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip QDoubleSpinBoxConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'QDoubleSpinBox :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
  toGc this'@(QDoubleSpinBoxConstGc {}) = HoppyP.return this'

instance QDoubleSpinBoxConstPtr QDoubleSpinBoxConst where
  toQDoubleSpinBoxConst = HoppyP.id

instance M366.QAbstractSpinBoxConstPtr QDoubleSpinBoxConst where
  toQAbstractSpinBoxConst (QDoubleSpinBoxConst ptr') = M366.QAbstractSpinBoxConst $ castQDoubleSpinBoxToQAbstractSpinBox ptr'
  toQAbstractSpinBoxConst (QDoubleSpinBoxConstGc fptr' ptr') = M366.QAbstractSpinBoxConstGc fptr' $ castQDoubleSpinBoxToQAbstractSpinBox ptr'

instance M506.QWidgetConstPtr QDoubleSpinBoxConst where
  toQWidgetConst (QDoubleSpinBoxConst ptr') = M506.QWidgetConst $ castQDoubleSpinBoxToQWidget ptr'
  toQWidgetConst (QDoubleSpinBoxConstGc fptr' ptr') = M506.QWidgetConstGc fptr' $ castQDoubleSpinBoxToQWidget ptr'

instance M94.QObjectConstPtr QDoubleSpinBoxConst where
  toQObjectConst (QDoubleSpinBoxConst ptr') = M94.QObjectConst $ castQDoubleSpinBoxToQObject ptr'
  toQObjectConst (QDoubleSpinBoxConstGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQDoubleSpinBoxToQObject ptr'

data QDoubleSpinBox =
    QDoubleSpinBox (HoppyF.Ptr QDoubleSpinBox)
  | QDoubleSpinBoxGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QDoubleSpinBox)
  deriving (HoppyP.Show)

instance HoppyP.Eq QDoubleSpinBox where
  x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y

instance HoppyP.Ord QDoubleSpinBox where
  compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)

castQDoubleSpinBoxToNonconst :: QDoubleSpinBoxConst -> QDoubleSpinBox
castQDoubleSpinBoxToNonconst (QDoubleSpinBoxConst ptr') = QDoubleSpinBox $ HoppyF.castPtr ptr'
castQDoubleSpinBoxToNonconst (QDoubleSpinBoxConstGc fptr' ptr') = QDoubleSpinBoxGc fptr' $ HoppyF.castPtr ptr'

instance HoppyFHR.CppPtr QDoubleSpinBox where
  nullptr = QDoubleSpinBox HoppyF.nullPtr
  
  withCppPtr (QDoubleSpinBox ptr') f' = f' ptr'
  withCppPtr (QDoubleSpinBoxGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
  
  toPtr (QDoubleSpinBox ptr') = ptr'
  toPtr (QDoubleSpinBoxGc _ ptr') = ptr'
  
  touchCppPtr (QDoubleSpinBox _) = HoppyP.return ()
  touchCppPtr (QDoubleSpinBoxGc fptr' _) = HoppyF.touchForeignPtr fptr'

instance HoppyFHR.Deletable QDoubleSpinBox where
  delete (QDoubleSpinBox ptr') = delete'QDoubleSpinBox $ (HoppyF.castPtr ptr' :: HoppyF.Ptr QDoubleSpinBoxConst)
  delete (QDoubleSpinBoxGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "QDoubleSpinBox", " object."]
  
  toGc this'@(QDoubleSpinBox ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip QDoubleSpinBoxGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'QDoubleSpinBox :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
  toGc this'@(QDoubleSpinBoxGc {}) = HoppyP.return this'

instance QDoubleSpinBoxConstPtr QDoubleSpinBox where
  toQDoubleSpinBoxConst (QDoubleSpinBox ptr') = QDoubleSpinBoxConst $ (HoppyF.castPtr :: HoppyF.Ptr QDoubleSpinBox -> HoppyF.Ptr QDoubleSpinBoxConst) ptr'
  toQDoubleSpinBoxConst (QDoubleSpinBoxGc fptr' ptr') = QDoubleSpinBoxConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QDoubleSpinBox -> HoppyF.Ptr QDoubleSpinBoxConst) ptr'

instance QDoubleSpinBoxPtr QDoubleSpinBox where
  toQDoubleSpinBox = HoppyP.id

instance M366.QAbstractSpinBoxConstPtr QDoubleSpinBox where
  toQAbstractSpinBoxConst (QDoubleSpinBox ptr') = M366.QAbstractSpinBoxConst $ castQDoubleSpinBoxToQAbstractSpinBox $ (HoppyF.castPtr :: HoppyF.Ptr QDoubleSpinBox -> HoppyF.Ptr QDoubleSpinBoxConst) ptr'
  toQAbstractSpinBoxConst (QDoubleSpinBoxGc fptr' ptr') = M366.QAbstractSpinBoxConstGc fptr' $ castQDoubleSpinBoxToQAbstractSpinBox $ (HoppyF.castPtr :: HoppyF.Ptr QDoubleSpinBox -> HoppyF.Ptr QDoubleSpinBoxConst) ptr'

instance M366.QAbstractSpinBoxPtr QDoubleSpinBox where
  toQAbstractSpinBox (QDoubleSpinBox ptr') = M366.QAbstractSpinBox $ (HoppyF.castPtr :: HoppyF.Ptr M366.QAbstractSpinBoxConst -> HoppyF.Ptr M366.QAbstractSpinBox) $ castQDoubleSpinBoxToQAbstractSpinBox $ (HoppyF.castPtr :: HoppyF.Ptr QDoubleSpinBox -> HoppyF.Ptr QDoubleSpinBoxConst) ptr'
  toQAbstractSpinBox (QDoubleSpinBoxGc fptr' ptr') = M366.QAbstractSpinBoxGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M366.QAbstractSpinBoxConst -> HoppyF.Ptr M366.QAbstractSpinBox) $ castQDoubleSpinBoxToQAbstractSpinBox $ (HoppyF.castPtr :: HoppyF.Ptr QDoubleSpinBox -> HoppyF.Ptr QDoubleSpinBoxConst) ptr'

instance M506.QWidgetConstPtr QDoubleSpinBox where
  toQWidgetConst (QDoubleSpinBox ptr') = M506.QWidgetConst $ castQDoubleSpinBoxToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QDoubleSpinBox -> HoppyF.Ptr QDoubleSpinBoxConst) ptr'
  toQWidgetConst (QDoubleSpinBoxGc fptr' ptr') = M506.QWidgetConstGc fptr' $ castQDoubleSpinBoxToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QDoubleSpinBox -> HoppyF.Ptr QDoubleSpinBoxConst) ptr'

instance M506.QWidgetPtr QDoubleSpinBox where
  toQWidget (QDoubleSpinBox ptr') = M506.QWidget $ (HoppyF.castPtr :: HoppyF.Ptr M506.QWidgetConst -> HoppyF.Ptr M506.QWidget) $ castQDoubleSpinBoxToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QDoubleSpinBox -> HoppyF.Ptr QDoubleSpinBoxConst) ptr'
  toQWidget (QDoubleSpinBoxGc fptr' ptr') = M506.QWidgetGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M506.QWidgetConst -> HoppyF.Ptr M506.QWidget) $ castQDoubleSpinBoxToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QDoubleSpinBox -> HoppyF.Ptr QDoubleSpinBoxConst) ptr'

instance M94.QObjectConstPtr QDoubleSpinBox where
  toQObjectConst (QDoubleSpinBox ptr') = M94.QObjectConst $ castQDoubleSpinBoxToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QDoubleSpinBox -> HoppyF.Ptr QDoubleSpinBoxConst) ptr'
  toQObjectConst (QDoubleSpinBoxGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQDoubleSpinBoxToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QDoubleSpinBox -> HoppyF.Ptr QDoubleSpinBoxConst) ptr'

instance M94.QObjectPtr QDoubleSpinBox where
  toQObject (QDoubleSpinBox ptr') = M94.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQDoubleSpinBoxToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QDoubleSpinBox -> HoppyF.Ptr QDoubleSpinBoxConst) ptr'
  toQObject (QDoubleSpinBoxGc fptr' ptr') = M94.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQDoubleSpinBoxToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QDoubleSpinBox -> HoppyF.Ptr QDoubleSpinBoxConst) ptr'

new :: (HoppyP.IO QDoubleSpinBox)
new =
  HoppyP.fmap QDoubleSpinBox
  (new')

newWithParent :: (M506.QWidgetPtr arg'1) => (arg'1) -> (HoppyP.IO QDoubleSpinBox)
newWithParent arg'1 =
  HoppyFHR.withCppPtr (M506.toQWidget arg'1) $ \arg'1' ->
  HoppyP.fmap QDoubleSpinBox
  (newWithParent' arg'1')

class QDoubleSpinBoxSuper a where
  downToQDoubleSpinBox :: a -> QDoubleSpinBox

instance QDoubleSpinBoxSuper M366.QAbstractSpinBox where
  downToQDoubleSpinBox = castQDoubleSpinBoxToNonconst . cast' . M366.castQAbstractSpinBoxToConst
    where
      cast' (M366.QAbstractSpinBoxConst ptr') = QDoubleSpinBoxConst $ castQAbstractSpinBoxToQDoubleSpinBox ptr'
      cast' (M366.QAbstractSpinBoxConstGc fptr' ptr') = QDoubleSpinBoxConstGc fptr' $ castQAbstractSpinBoxToQDoubleSpinBox ptr'
instance QDoubleSpinBoxSuper M506.QWidget where
  downToQDoubleSpinBox = castQDoubleSpinBoxToNonconst . cast' . M506.castQWidgetToConst
    where
      cast' (M506.QWidgetConst ptr') = QDoubleSpinBoxConst $ castQWidgetToQDoubleSpinBox ptr'
      cast' (M506.QWidgetConstGc fptr' ptr') = QDoubleSpinBoxConstGc fptr' $ castQWidgetToQDoubleSpinBox ptr'
instance QDoubleSpinBoxSuper M94.QObject where
  downToQDoubleSpinBox = castQDoubleSpinBoxToNonconst . cast' . M94.castQObjectToConst
    where
      cast' (M94.QObjectConst ptr') = QDoubleSpinBoxConst $ castQObjectToQDoubleSpinBox ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QDoubleSpinBoxConstGc fptr' $ castQObjectToQDoubleSpinBox ptr'

class QDoubleSpinBoxSuperConst a where
  downToQDoubleSpinBoxConst :: a -> QDoubleSpinBoxConst

instance QDoubleSpinBoxSuperConst M366.QAbstractSpinBoxConst where
  downToQDoubleSpinBoxConst = cast'
    where
      cast' (M366.QAbstractSpinBoxConst ptr') = QDoubleSpinBoxConst $ castQAbstractSpinBoxToQDoubleSpinBox ptr'
      cast' (M366.QAbstractSpinBoxConstGc fptr' ptr') = QDoubleSpinBoxConstGc fptr' $ castQAbstractSpinBoxToQDoubleSpinBox ptr'
instance QDoubleSpinBoxSuperConst M506.QWidgetConst where
  downToQDoubleSpinBoxConst = cast'
    where
      cast' (M506.QWidgetConst ptr') = QDoubleSpinBoxConst $ castQWidgetToQDoubleSpinBox ptr'
      cast' (M506.QWidgetConstGc fptr' ptr') = QDoubleSpinBoxConstGc fptr' $ castQWidgetToQDoubleSpinBox ptr'
instance QDoubleSpinBoxSuperConst M94.QObjectConst where
  downToQDoubleSpinBoxConst = cast'
    where
      cast' (M94.QObjectConst ptr') = QDoubleSpinBoxConst $ castQObjectToQDoubleSpinBox ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QDoubleSpinBoxConstGc fptr' $ castQObjectToQDoubleSpinBox ptr'

instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr QDoubleSpinBox)) QDoubleSpinBox where
  assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'

instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr QDoubleSpinBox)) QDoubleSpinBox where
  decode = HoppyP.fmap QDoubleSpinBox . HoppyF.peek