QValidator.hs

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

module Graphics.UI.Qtah.Generated.Gui.QValidator (
  castQValidatorToQObject,
  castQObjectToQValidator,
  QValidatorValue (..),
  QValidatorConstPtr (..),
  fixup,
  validate,
  QValidatorPtr (..),
  emitChanged,
  QValidatorConst (..),
  castQValidatorToConst,
  QValidator (..),
  castQValidatorToNonconst,
  QValidatorSuper (..),
  QValidatorSuperConst (..),
  QValidatorState (..),
  ) 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 Prelude (($), (.), (=<<), (==))
import qualified Prelude as HoppyP

foreign import ccall "genpop__QValidator_fixup" fixup' ::  HoppyF.Ptr QValidatorConst -> HoppyF.Ptr M142.QString -> HoppyP.IO ()
foreign import ccall "genpop__QValidator_validate" validate' ::  HoppyF.Ptr QValidatorConst -> HoppyF.Ptr M142.QString -> HoppyF.Ptr HoppyFC.CInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QValidator_emitChanged" emitChanged' ::  HoppyF.Ptr QValidator -> HoppyP.IO ()
foreign import ccall "gencast__QValidator__QObject" castQValidatorToQObject :: HoppyF.Ptr QValidatorConst -> HoppyF.Ptr M94.QObjectConst
foreign import ccall "gencast__QObject__QValidator" castQObjectToQValidator :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr QValidatorConst
foreign import ccall "gendel__QValidator" delete'QValidator :: HoppyF.Ptr QValidatorConst -> HoppyP.IO ()
foreign import ccall "&gendel__QValidator" deletePtr'QValidator :: HoppyF.FunPtr (HoppyF.Ptr QValidatorConst -> HoppyP.IO ())

class QValidatorValue a where
  withQValidatorPtr :: a -> (QValidatorConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QValidatorConstPtr a => QValidatorValue a where
  withQValidatorPtr = HoppyP.flip ($) . toQValidatorConst

class (M94.QObjectConstPtr this) => QValidatorConstPtr this where
  toQValidatorConst :: this -> QValidatorConst

fixup :: (QValidatorValue this, M142.QStringPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
fixup arg'1 arg'2 =
  withQValidatorPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyFHR.withCppPtr (M142.toQString arg'2) $ \arg'2' ->
  (fixup' arg'1' arg'2')

validate :: (QValidatorValue this, M142.QStringPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyF.Ptr HoppyFC.CInt) -> (HoppyP.IO QValidatorState)
validate arg'1 arg'2 arg'3 =
  withQValidatorPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyFHR.withCppPtr (M142.toQString arg'2) $ \arg'2' ->
  let arg'3' = arg'3 in
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (validate' arg'1' arg'2' arg'3')

class (QValidatorConstPtr this, M94.QObjectPtr this) => QValidatorPtr this where
  toQValidator :: this -> QValidator

emitChanged :: (QValidatorPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
emitChanged arg'1 =
  HoppyFHR.withCppPtr (toQValidator arg'1) $ \arg'1' ->
  (emitChanged' arg'1')

data QValidatorConst =
    QValidatorConst (HoppyF.Ptr QValidatorConst)
  | QValidatorConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QValidatorConst)
  deriving (HoppyP.Show)

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

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

castQValidatorToConst :: QValidator -> QValidatorConst
castQValidatorToConst (QValidator ptr') = QValidatorConst $ HoppyF.castPtr ptr'
castQValidatorToConst (QValidatorGc fptr' ptr') = QValidatorConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QValidatorConstPtr QValidatorConst where
  toQValidatorConst = HoppyP.id

instance M94.QObjectConstPtr QValidatorConst where
  toQObjectConst (QValidatorConst ptr') = M94.QObjectConst $ castQValidatorToQObject ptr'
  toQObjectConst (QValidatorConstGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQValidatorToQObject ptr'

data QValidator =
    QValidator (HoppyF.Ptr QValidator)
  | QValidatorGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QValidator)
  deriving (HoppyP.Show)

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

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

castQValidatorToNonconst :: QValidatorConst -> QValidator
castQValidatorToNonconst (QValidatorConst ptr') = QValidator $ HoppyF.castPtr ptr'
castQValidatorToNonconst (QValidatorConstGc fptr' ptr') = QValidatorGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QValidatorConstPtr QValidator where
  toQValidatorConst (QValidator ptr') = QValidatorConst $ (HoppyF.castPtr :: HoppyF.Ptr QValidator -> HoppyF.Ptr QValidatorConst) ptr'
  toQValidatorConst (QValidatorGc fptr' ptr') = QValidatorConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QValidator -> HoppyF.Ptr QValidatorConst) ptr'

instance QValidatorPtr QValidator where
  toQValidator = HoppyP.id

instance M94.QObjectConstPtr QValidator where
  toQObjectConst (QValidator ptr') = M94.QObjectConst $ castQValidatorToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QValidator -> HoppyF.Ptr QValidatorConst) ptr'
  toQObjectConst (QValidatorGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQValidatorToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QValidator -> HoppyF.Ptr QValidatorConst) ptr'

instance M94.QObjectPtr QValidator where
  toQObject (QValidator ptr') = M94.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQValidatorToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QValidator -> HoppyF.Ptr QValidatorConst) ptr'
  toQObject (QValidatorGc fptr' ptr') = M94.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQValidatorToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QValidator -> HoppyF.Ptr QValidatorConst) ptr'

class QValidatorSuper a where
  downToQValidator :: a -> QValidator

instance QValidatorSuper M94.QObject where
  downToQValidator = castQValidatorToNonconst . cast' . M94.castQObjectToConst
    where
      cast' (M94.QObjectConst ptr') = QValidatorConst $ castQObjectToQValidator ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QValidatorConstGc fptr' $ castQObjectToQValidator ptr'

class QValidatorSuperConst a where
  downToQValidatorConst :: a -> QValidatorConst

instance QValidatorSuperConst M94.QObjectConst where
  downToQValidatorConst = cast'
    where
      cast' (M94.QObjectConst ptr') = QValidatorConst $ castQObjectToQValidator ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QValidatorConstGc fptr' $ castQObjectToQValidator ptr'

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

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

data QValidatorState =
  Invalid
  | Intermediate
  | Acceptable
  | UnknownQValidatorState (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QValidatorState where
  fromCppEnum Invalid = 0
  fromCppEnum Intermediate = 1
  fromCppEnum Acceptable = 2
  fromCppEnum (UnknownQValidatorState n) = n
  
  toCppEnum (0) = Invalid
  toCppEnum (1) = Intermediate
  toCppEnum (2) = Acceptable
  toCppEnum n = UnknownQValidatorState n

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

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