QVariantAnimation.hs

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

module Graphics.UI.Qtah.Generated.Core.QVariantAnimation (
  castQVariantAnimationToQAbstractAnimation,
  castQAbstractAnimationToQVariantAnimation,
  castQVariantAnimationToQObject,
  castQObjectToQVariantAnimation,
  QVariantAnimationValue (..),
  QVariantAnimationConstPtr (..),
  endValue,
  startValue,
  keyValueAt,
  QVariantAnimationPtr (..),
  setEndValue,
  setStartValue,
  setKeyValueAt,
  emitValueChanged,
  QVariantAnimationConst (..),
  castQVariantAnimationToConst,
  QVariantAnimation (..),
  castQVariantAnimationToNonconst,
  QVariantAnimationSuper (..),
  QVariantAnimationSuperConst (..),
  ) 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.QAbstractAnimation as M2
import qualified Graphics.UI.Qtah.Generated.Core.QObject as M94
import qualified Graphics.UI.Qtah.Generated.Core.QVariant as M168
import Prelude (($), (.), (=<<), (==), (>>=))
import qualified Prelude as HoppyP

foreign import ccall "genpop__QVariantAnimation_endValue" endValue' ::  HoppyF.Ptr QVariantAnimationConst -> HoppyP.IO (HoppyF.Ptr M168.QVariantConst)
foreign import ccall "genpop__QVariantAnimation_setEndValue" setEndValue' ::  HoppyF.Ptr QVariantAnimation -> HoppyF.Ptr M168.QVariantConst -> HoppyP.IO ()
foreign import ccall "genpop__QVariantAnimation_startValue" startValue' ::  HoppyF.Ptr QVariantAnimationConst -> HoppyP.IO (HoppyF.Ptr M168.QVariantConst)
foreign import ccall "genpop__QVariantAnimation_setStartValue" setStartValue' ::  HoppyF.Ptr QVariantAnimation -> HoppyF.Ptr M168.QVariantConst -> HoppyP.IO ()
foreign import ccall "genpop__QVariantAnimation_keyValueAt" keyValueAt' ::  HoppyF.Ptr QVariantAnimationConst -> HoppyFC.CDouble -> HoppyP.IO (HoppyF.Ptr M168.QVariantConst)
foreign import ccall "genpop__QVariantAnimation_setKeyValueAt" setKeyValueAt' ::  HoppyF.Ptr QVariantAnimation -> HoppyFC.CDouble -> HoppyF.Ptr M168.QVariantConst -> HoppyP.IO ()
foreign import ccall "genpop__QVariantAnimation_emitValueChanged" emitValueChanged' ::  HoppyF.Ptr QVariantAnimation -> HoppyF.Ptr M168.QVariantConst -> HoppyP.IO ()
foreign import ccall "gencast__QVariantAnimation__QAbstractAnimation" castQVariantAnimationToQAbstractAnimation :: HoppyF.Ptr QVariantAnimationConst -> HoppyF.Ptr M2.QAbstractAnimationConst
foreign import ccall "gencast__QAbstractAnimation__QVariantAnimation" castQAbstractAnimationToQVariantAnimation :: HoppyF.Ptr M2.QAbstractAnimationConst -> HoppyF.Ptr QVariantAnimationConst
foreign import ccall "gencast__QVariantAnimation__QObject" castQVariantAnimationToQObject :: HoppyF.Ptr QVariantAnimationConst -> HoppyF.Ptr M94.QObjectConst
foreign import ccall "gencast__QObject__QVariantAnimation" castQObjectToQVariantAnimation :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr QVariantAnimationConst
foreign import ccall "gendel__QVariantAnimation" delete'QVariantAnimation :: HoppyF.Ptr QVariantAnimationConst -> HoppyP.IO ()
foreign import ccall "&gendel__QVariantAnimation" deletePtr'QVariantAnimation :: HoppyF.FunPtr (HoppyF.Ptr QVariantAnimationConst -> HoppyP.IO ())

class QVariantAnimationValue a where
  withQVariantAnimationPtr :: a -> (QVariantAnimationConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QVariantAnimationConstPtr a => QVariantAnimationValue a where
  withQVariantAnimationPtr = HoppyP.flip ($) . toQVariantAnimationConst

class (M2.QAbstractAnimationConstPtr this) => QVariantAnimationConstPtr this where
  toQVariantAnimationConst :: this -> QVariantAnimationConst

endValue :: (QVariantAnimationValue this) => (this) {- ^ this -} -> (HoppyP.IO M168.QVariant)
endValue arg'1 =
  withQVariantAnimationPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M168.QVariantConst) =<<
  (endValue' arg'1')

startValue :: (QVariantAnimationValue this) => (this) {- ^ this -} -> (HoppyP.IO M168.QVariant)
startValue arg'1 =
  withQVariantAnimationPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M168.QVariantConst) =<<
  (startValue' arg'1')

keyValueAt :: (QVariantAnimationValue this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.IO M168.QVariant)
keyValueAt arg'1 arg'2 =
  withQVariantAnimationPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M168.QVariantConst) =<<
  (keyValueAt' arg'1' arg'2')

class (QVariantAnimationConstPtr this, M2.QAbstractAnimationPtr this) => QVariantAnimationPtr this where
  toQVariantAnimation :: this -> QVariantAnimation

setEndValue :: (QVariantAnimationPtr this, M168.QVariantValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setEndValue arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVariantAnimation arg'1) $ \arg'1' ->
  M168.withQVariantPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setEndValue' arg'1' arg'2')

setStartValue :: (QVariantAnimationPtr this, M168.QVariantValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setStartValue arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVariantAnimation arg'1) $ \arg'1' ->
  M168.withQVariantPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setStartValue' arg'1' arg'2')

setKeyValueAt :: (QVariantAnimationPtr this, M168.QVariantValue arg'3) => (this) {- ^ this -} -> (HoppyP.Double) -> (arg'3) -> (HoppyP.IO ())
setKeyValueAt arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQVariantAnimation arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  M168.withQVariantPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (setKeyValueAt' arg'1' arg'2' arg'3')

emitValueChanged :: (QVariantAnimationPtr this, M168.QVariantValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
emitValueChanged arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVariantAnimation arg'1) $ \arg'1' ->
  M168.withQVariantPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (emitValueChanged' arg'1' arg'2')

data QVariantAnimationConst =
    QVariantAnimationConst (HoppyF.Ptr QVariantAnimationConst)
  | QVariantAnimationConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QVariantAnimationConst)
  deriving (HoppyP.Show)

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

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

castQVariantAnimationToConst :: QVariantAnimation -> QVariantAnimationConst
castQVariantAnimationToConst (QVariantAnimation ptr') = QVariantAnimationConst $ HoppyF.castPtr ptr'
castQVariantAnimationToConst (QVariantAnimationGc fptr' ptr') = QVariantAnimationConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QVariantAnimationConstPtr QVariantAnimationConst where
  toQVariantAnimationConst = HoppyP.id

instance M2.QAbstractAnimationConstPtr QVariantAnimationConst where
  toQAbstractAnimationConst (QVariantAnimationConst ptr') = M2.QAbstractAnimationConst $ castQVariantAnimationToQAbstractAnimation ptr'
  toQAbstractAnimationConst (QVariantAnimationConstGc fptr' ptr') = M2.QAbstractAnimationConstGc fptr' $ castQVariantAnimationToQAbstractAnimation ptr'

instance M94.QObjectConstPtr QVariantAnimationConst where
  toQObjectConst (QVariantAnimationConst ptr') = M94.QObjectConst $ castQVariantAnimationToQObject ptr'
  toQObjectConst (QVariantAnimationConstGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQVariantAnimationToQObject ptr'

data QVariantAnimation =
    QVariantAnimation (HoppyF.Ptr QVariantAnimation)
  | QVariantAnimationGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QVariantAnimation)
  deriving (HoppyP.Show)

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

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

castQVariantAnimationToNonconst :: QVariantAnimationConst -> QVariantAnimation
castQVariantAnimationToNonconst (QVariantAnimationConst ptr') = QVariantAnimation $ HoppyF.castPtr ptr'
castQVariantAnimationToNonconst (QVariantAnimationConstGc fptr' ptr') = QVariantAnimationGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QVariantAnimationConstPtr QVariantAnimation where
  toQVariantAnimationConst (QVariantAnimation ptr') = QVariantAnimationConst $ (HoppyF.castPtr :: HoppyF.Ptr QVariantAnimation -> HoppyF.Ptr QVariantAnimationConst) ptr'
  toQVariantAnimationConst (QVariantAnimationGc fptr' ptr') = QVariantAnimationConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QVariantAnimation -> HoppyF.Ptr QVariantAnimationConst) ptr'

instance QVariantAnimationPtr QVariantAnimation where
  toQVariantAnimation = HoppyP.id

instance M2.QAbstractAnimationConstPtr QVariantAnimation where
  toQAbstractAnimationConst (QVariantAnimation ptr') = M2.QAbstractAnimationConst $ castQVariantAnimationToQAbstractAnimation $ (HoppyF.castPtr :: HoppyF.Ptr QVariantAnimation -> HoppyF.Ptr QVariantAnimationConst) ptr'
  toQAbstractAnimationConst (QVariantAnimationGc fptr' ptr') = M2.QAbstractAnimationConstGc fptr' $ castQVariantAnimationToQAbstractAnimation $ (HoppyF.castPtr :: HoppyF.Ptr QVariantAnimation -> HoppyF.Ptr QVariantAnimationConst) ptr'

instance M2.QAbstractAnimationPtr QVariantAnimation where
  toQAbstractAnimation (QVariantAnimation ptr') = M2.QAbstractAnimation $ (HoppyF.castPtr :: HoppyF.Ptr M2.QAbstractAnimationConst -> HoppyF.Ptr M2.QAbstractAnimation) $ castQVariantAnimationToQAbstractAnimation $ (HoppyF.castPtr :: HoppyF.Ptr QVariantAnimation -> HoppyF.Ptr QVariantAnimationConst) ptr'
  toQAbstractAnimation (QVariantAnimationGc fptr' ptr') = M2.QAbstractAnimationGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M2.QAbstractAnimationConst -> HoppyF.Ptr M2.QAbstractAnimation) $ castQVariantAnimationToQAbstractAnimation $ (HoppyF.castPtr :: HoppyF.Ptr QVariantAnimation -> HoppyF.Ptr QVariantAnimationConst) ptr'

instance M94.QObjectConstPtr QVariantAnimation where
  toQObjectConst (QVariantAnimation ptr') = M94.QObjectConst $ castQVariantAnimationToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QVariantAnimation -> HoppyF.Ptr QVariantAnimationConst) ptr'
  toQObjectConst (QVariantAnimationGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQVariantAnimationToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QVariantAnimation -> HoppyF.Ptr QVariantAnimationConst) ptr'

instance M94.QObjectPtr QVariantAnimation where
  toQObject (QVariantAnimation ptr') = M94.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQVariantAnimationToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QVariantAnimation -> HoppyF.Ptr QVariantAnimationConst) ptr'
  toQObject (QVariantAnimationGc fptr' ptr') = M94.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQVariantAnimationToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QVariantAnimation -> HoppyF.Ptr QVariantAnimationConst) ptr'

class QVariantAnimationSuper a where
  downToQVariantAnimation :: a -> QVariantAnimation

instance QVariantAnimationSuper M2.QAbstractAnimation where
  downToQVariantAnimation = castQVariantAnimationToNonconst . cast' . M2.castQAbstractAnimationToConst
    where
      cast' (M2.QAbstractAnimationConst ptr') = QVariantAnimationConst $ castQAbstractAnimationToQVariantAnimation ptr'
      cast' (M2.QAbstractAnimationConstGc fptr' ptr') = QVariantAnimationConstGc fptr' $ castQAbstractAnimationToQVariantAnimation ptr'
instance QVariantAnimationSuper M94.QObject where
  downToQVariantAnimation = castQVariantAnimationToNonconst . cast' . M94.castQObjectToConst
    where
      cast' (M94.QObjectConst ptr') = QVariantAnimationConst $ castQObjectToQVariantAnimation ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QVariantAnimationConstGc fptr' $ castQObjectToQVariantAnimation ptr'

class QVariantAnimationSuperConst a where
  downToQVariantAnimationConst :: a -> QVariantAnimationConst

instance QVariantAnimationSuperConst M2.QAbstractAnimationConst where
  downToQVariantAnimationConst = cast'
    where
      cast' (M2.QAbstractAnimationConst ptr') = QVariantAnimationConst $ castQAbstractAnimationToQVariantAnimation ptr'
      cast' (M2.QAbstractAnimationConstGc fptr' ptr') = QVariantAnimationConstGc fptr' $ castQAbstractAnimationToQVariantAnimation ptr'
instance QVariantAnimationSuperConst M94.QObjectConst where
  downToQVariantAnimationConst = cast'
    where
      cast' (M94.QObjectConst ptr') = QVariantAnimationConst $ castQObjectToQVariantAnimation ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QVariantAnimationConstGc fptr' $ castQObjectToQVariantAnimation ptr'

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

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