QDoubleValidator.hs

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

module Graphics.UI.Qtah.Generated.Gui.QDoubleValidator (
  castQDoubleValidatorToQValidator,
  castQValidatorToQDoubleValidator,
  castQDoubleValidatorToQObject,
  castQObjectToQDoubleValidator,
  QDoubleValidatorValue (..),
  QDoubleValidatorConstPtr (..),
  bottom,
  decimals,
  notation,
  top,
  QDoubleValidatorPtr (..),
  setBottom,
  setDecimals,
  setNotation,
  setRange,
  setRangeAndDecimals,
  setTop,
  QDoubleValidatorConst (..),
  castQDoubleValidatorToConst,
  QDoubleValidator (..),
  castQDoubleValidatorToNonconst,
  new,
  newWithParent,
  newWithOptions,
  newWithOptionsAndParent,
  QDoubleValidatorSuper (..),
  QDoubleValidatorSuperConst (..),
  QDoubleValidatorNotation (..),
  ) 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.Gui.QValidator as M338
import Prelude (($), (.), (=<<), (==), (>>=))
import qualified Prelude as HoppyP

foreign import ccall "genpop__QDoubleValidator_new" new' ::  HoppyP.IO (HoppyF.Ptr QDoubleValidator)
foreign import ccall "genpop__QDoubleValidator_newWithParent" newWithParent' ::  HoppyF.Ptr M94.QObject -> HoppyP.IO (HoppyF.Ptr QDoubleValidator)
foreign import ccall "genpop__QDoubleValidator_newWithOptions" newWithOptions' ::  HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QDoubleValidator)
foreign import ccall "genpop__QDoubleValidator_newWithOptionsAndParent" newWithOptionsAndParent' ::  HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyFC.CInt -> HoppyF.Ptr M94.QObject -> HoppyP.IO (HoppyF.Ptr QDoubleValidator)
foreign import ccall "genpop__QDoubleValidator_bottom" bottom' ::  HoppyF.Ptr QDoubleValidatorConst -> HoppyP.IO HoppyFC.CDouble
foreign import ccall "genpop__QDoubleValidator_setBottom" setBottom' ::  HoppyF.Ptr QDoubleValidator -> HoppyFC.CDouble -> HoppyP.IO ()
foreign import ccall "genpop__QDoubleValidator_decimals" decimals' ::  HoppyF.Ptr QDoubleValidatorConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QDoubleValidator_setDecimals" setDecimals' ::  HoppyF.Ptr QDoubleValidator -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QDoubleValidator_notation" notation' ::  HoppyF.Ptr QDoubleValidatorConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QDoubleValidator_setNotation" setNotation' ::  HoppyF.Ptr QDoubleValidator -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QDoubleValidator_setRange" setRange' ::  HoppyF.Ptr QDoubleValidator -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyP.IO ()
foreign import ccall "genpop__QDoubleValidator_setRangeAndDecimals" setRangeAndDecimals' ::  HoppyF.Ptr QDoubleValidator -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QDoubleValidator_top" top' ::  HoppyF.Ptr QDoubleValidatorConst -> HoppyP.IO HoppyFC.CDouble
foreign import ccall "genpop__QDoubleValidator_setTop" setTop' ::  HoppyF.Ptr QDoubleValidator -> HoppyFC.CDouble -> HoppyP.IO ()
foreign import ccall "gencast__QDoubleValidator__QValidator" castQDoubleValidatorToQValidator :: HoppyF.Ptr QDoubleValidatorConst -> HoppyF.Ptr M338.QValidatorConst
foreign import ccall "gencast__QValidator__QDoubleValidator" castQValidatorToQDoubleValidator :: HoppyF.Ptr M338.QValidatorConst -> HoppyF.Ptr QDoubleValidatorConst
foreign import ccall "gencast__QDoubleValidator__QObject" castQDoubleValidatorToQObject :: HoppyF.Ptr QDoubleValidatorConst -> HoppyF.Ptr M94.QObjectConst
foreign import ccall "gencast__QObject__QDoubleValidator" castQObjectToQDoubleValidator :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr QDoubleValidatorConst
foreign import ccall "gendel__QDoubleValidator" delete'QDoubleValidator :: HoppyF.Ptr QDoubleValidatorConst -> HoppyP.IO ()
foreign import ccall "&gendel__QDoubleValidator" deletePtr'QDoubleValidator :: HoppyF.FunPtr (HoppyF.Ptr QDoubleValidatorConst -> HoppyP.IO ())

class QDoubleValidatorValue a where
  withQDoubleValidatorPtr :: a -> (QDoubleValidatorConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QDoubleValidatorConstPtr a => QDoubleValidatorValue a where
  withQDoubleValidatorPtr = HoppyP.flip ($) . toQDoubleValidatorConst

class (M338.QValidatorConstPtr this) => QDoubleValidatorConstPtr this where
  toQDoubleValidatorConst :: this -> QDoubleValidatorConst

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

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

notation :: (QDoubleValidatorValue this) => (this) {- ^ this -} -> (HoppyP.IO QDoubleValidatorNotation)
notation arg'1 =
  withQDoubleValidatorPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (notation' arg'1')

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

class (QDoubleValidatorConstPtr this, M338.QValidatorPtr this) => QDoubleValidatorPtr this where
  toQDoubleValidator :: this -> QDoubleValidator

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

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

setNotation :: (QDoubleValidatorPtr this) => (this) {- ^ this -} -> (QDoubleValidatorNotation) -> (HoppyP.IO ())
setNotation arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQDoubleValidator arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (setNotation' arg'1' arg'2')

setRange :: (QDoubleValidatorPtr this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.IO ())
setRange arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQDoubleValidator 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')

setRangeAndDecimals :: (QDoubleValidatorPtr this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.Int) -> (HoppyP.IO ())
setRangeAndDecimals arg'1 arg'2 arg'3 arg'4 =
  HoppyFHR.withCppPtr (toQDoubleValidator arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'4 >>= \arg'4' ->
  (setRangeAndDecimals' arg'1' arg'2' arg'3' arg'4')

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

data QDoubleValidatorConst =
    QDoubleValidatorConst (HoppyF.Ptr QDoubleValidatorConst)
  | QDoubleValidatorConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QDoubleValidatorConst)
  deriving (HoppyP.Show)

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

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

castQDoubleValidatorToConst :: QDoubleValidator -> QDoubleValidatorConst
castQDoubleValidatorToConst (QDoubleValidator ptr') = QDoubleValidatorConst $ HoppyF.castPtr ptr'
castQDoubleValidatorToConst (QDoubleValidatorGc fptr' ptr') = QDoubleValidatorConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QDoubleValidatorConstPtr QDoubleValidatorConst where
  toQDoubleValidatorConst = HoppyP.id

instance M338.QValidatorConstPtr QDoubleValidatorConst where
  toQValidatorConst (QDoubleValidatorConst ptr') = M338.QValidatorConst $ castQDoubleValidatorToQValidator ptr'
  toQValidatorConst (QDoubleValidatorConstGc fptr' ptr') = M338.QValidatorConstGc fptr' $ castQDoubleValidatorToQValidator ptr'

instance M94.QObjectConstPtr QDoubleValidatorConst where
  toQObjectConst (QDoubleValidatorConst ptr') = M94.QObjectConst $ castQDoubleValidatorToQObject ptr'
  toQObjectConst (QDoubleValidatorConstGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQDoubleValidatorToQObject ptr'

data QDoubleValidator =
    QDoubleValidator (HoppyF.Ptr QDoubleValidator)
  | QDoubleValidatorGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QDoubleValidator)
  deriving (HoppyP.Show)

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

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

castQDoubleValidatorToNonconst :: QDoubleValidatorConst -> QDoubleValidator
castQDoubleValidatorToNonconst (QDoubleValidatorConst ptr') = QDoubleValidator $ HoppyF.castPtr ptr'
castQDoubleValidatorToNonconst (QDoubleValidatorConstGc fptr' ptr') = QDoubleValidatorGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QDoubleValidatorConstPtr QDoubleValidator where
  toQDoubleValidatorConst (QDoubleValidator ptr') = QDoubleValidatorConst $ (HoppyF.castPtr :: HoppyF.Ptr QDoubleValidator -> HoppyF.Ptr QDoubleValidatorConst) ptr'
  toQDoubleValidatorConst (QDoubleValidatorGc fptr' ptr') = QDoubleValidatorConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QDoubleValidator -> HoppyF.Ptr QDoubleValidatorConst) ptr'

instance QDoubleValidatorPtr QDoubleValidator where
  toQDoubleValidator = HoppyP.id

instance M338.QValidatorConstPtr QDoubleValidator where
  toQValidatorConst (QDoubleValidator ptr') = M338.QValidatorConst $ castQDoubleValidatorToQValidator $ (HoppyF.castPtr :: HoppyF.Ptr QDoubleValidator -> HoppyF.Ptr QDoubleValidatorConst) ptr'
  toQValidatorConst (QDoubleValidatorGc fptr' ptr') = M338.QValidatorConstGc fptr' $ castQDoubleValidatorToQValidator $ (HoppyF.castPtr :: HoppyF.Ptr QDoubleValidator -> HoppyF.Ptr QDoubleValidatorConst) ptr'

instance M338.QValidatorPtr QDoubleValidator where
  toQValidator (QDoubleValidator ptr') = M338.QValidator $ (HoppyF.castPtr :: HoppyF.Ptr M338.QValidatorConst -> HoppyF.Ptr M338.QValidator) $ castQDoubleValidatorToQValidator $ (HoppyF.castPtr :: HoppyF.Ptr QDoubleValidator -> HoppyF.Ptr QDoubleValidatorConst) ptr'
  toQValidator (QDoubleValidatorGc fptr' ptr') = M338.QValidatorGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M338.QValidatorConst -> HoppyF.Ptr M338.QValidator) $ castQDoubleValidatorToQValidator $ (HoppyF.castPtr :: HoppyF.Ptr QDoubleValidator -> HoppyF.Ptr QDoubleValidatorConst) ptr'

instance M94.QObjectConstPtr QDoubleValidator where
  toQObjectConst (QDoubleValidator ptr') = M94.QObjectConst $ castQDoubleValidatorToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QDoubleValidator -> HoppyF.Ptr QDoubleValidatorConst) ptr'
  toQObjectConst (QDoubleValidatorGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQDoubleValidatorToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QDoubleValidator -> HoppyF.Ptr QDoubleValidatorConst) ptr'

instance M94.QObjectPtr QDoubleValidator where
  toQObject (QDoubleValidator ptr') = M94.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQDoubleValidatorToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QDoubleValidator -> HoppyF.Ptr QDoubleValidatorConst) ptr'
  toQObject (QDoubleValidatorGc fptr' ptr') = M94.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQDoubleValidatorToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QDoubleValidator -> HoppyF.Ptr QDoubleValidatorConst) ptr'

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

newWithParent :: (M94.QObjectPtr arg'1) => (arg'1) -> (HoppyP.IO QDoubleValidator)
newWithParent arg'1 =
  HoppyFHR.withCppPtr (M94.toQObject arg'1) $ \arg'1' ->
  HoppyP.fmap QDoubleValidator
  (newWithParent' arg'1')

newWithOptions :: (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.Int) -> (HoppyP.IO QDoubleValidator)
newWithOptions arg'1 arg'2 arg'3 =
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'1 >>= \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  HoppyP.fmap QDoubleValidator
  (newWithOptions' arg'1' arg'2' arg'3')

newWithOptionsAndParent :: (M94.QObjectPtr arg'4) => (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.Int) -> (arg'4) -> (HoppyP.IO QDoubleValidator)
newWithOptionsAndParent arg'1 arg'2 arg'3 arg'4 =
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'1 >>= \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  HoppyFHR.withCppPtr (M94.toQObject arg'4) $ \arg'4' ->
  HoppyP.fmap QDoubleValidator
  (newWithOptionsAndParent' arg'1' arg'2' arg'3' arg'4')

class QDoubleValidatorSuper a where
  downToQDoubleValidator :: a -> QDoubleValidator

instance QDoubleValidatorSuper M338.QValidator where
  downToQDoubleValidator = castQDoubleValidatorToNonconst . cast' . M338.castQValidatorToConst
    where
      cast' (M338.QValidatorConst ptr') = QDoubleValidatorConst $ castQValidatorToQDoubleValidator ptr'
      cast' (M338.QValidatorConstGc fptr' ptr') = QDoubleValidatorConstGc fptr' $ castQValidatorToQDoubleValidator ptr'
instance QDoubleValidatorSuper M94.QObject where
  downToQDoubleValidator = castQDoubleValidatorToNonconst . cast' . M94.castQObjectToConst
    where
      cast' (M94.QObjectConst ptr') = QDoubleValidatorConst $ castQObjectToQDoubleValidator ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QDoubleValidatorConstGc fptr' $ castQObjectToQDoubleValidator ptr'

class QDoubleValidatorSuperConst a where
  downToQDoubleValidatorConst :: a -> QDoubleValidatorConst

instance QDoubleValidatorSuperConst M338.QValidatorConst where
  downToQDoubleValidatorConst = cast'
    where
      cast' (M338.QValidatorConst ptr') = QDoubleValidatorConst $ castQValidatorToQDoubleValidator ptr'
      cast' (M338.QValidatorConstGc fptr' ptr') = QDoubleValidatorConstGc fptr' $ castQValidatorToQDoubleValidator ptr'
instance QDoubleValidatorSuperConst M94.QObjectConst where
  downToQDoubleValidatorConst = cast'
    where
      cast' (M94.QObjectConst ptr') = QDoubleValidatorConst $ castQObjectToQDoubleValidator ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QDoubleValidatorConstGc fptr' $ castQObjectToQDoubleValidator ptr'

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

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

data QDoubleValidatorNotation =
  StandardNotation
  | ScientificNotation
  | UnknownQDoubleValidatorNotation (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QDoubleValidatorNotation where
  fromCppEnum StandardNotation = 0
  fromCppEnum ScientificNotation = 1
  fromCppEnum (UnknownQDoubleValidatorNotation n) = n
  
  toCppEnum (0) = StandardNotation
  toCppEnum (1) = ScientificNotation
  toCppEnum n = UnknownQDoubleValidatorNotation n

instance HoppyP.Eq QDoubleValidatorNotation where
  x == y = HoppyFHR.fromCppEnum x == HoppyFHR.fromCppEnum y

instance HoppyP.Ord QDoubleValidatorNotation where
  compare x y = HoppyP.compare (HoppyFHR.fromCppEnum x) (HoppyFHR.fromCppEnum y)