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

module Graphics.UI.Qtah.Generated.Core.QAnimationGroup (
  castQAnimationGroupToQAbstractAnimation,
  castQAbstractAnimationToQAnimationGroup,
  castQAnimationGroupToQObject,
  castQObjectToQAnimationGroup,
  QAnimationGroupValue (..),
  QAnimationGroupConstPtr (..),
  animationAt,
  animationCount,
  duration,
  indexOfAnimation,
  QAnimationGroupPtr (..),
  addAnimation,
  clear,
  insertAnimation,
  removeAnimation,
  takeAnimation,
  QAnimationGroupConst (..),
  castQAnimationGroupToConst,
  QAnimationGroup (..),
  castQAnimationGroupToNonconst,
  QAnimationGroupSuper (..),
  QAnimationGroupSuperConst (..),
  ) 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 Prelude (($), (.), (=<<), (==), (>>=))
import qualified Prelude as HoppyP

foreign import ccall "genpop__QAnimationGroup_addAnimation" addAnimation' ::  HoppyF.Ptr QAnimationGroup -> HoppyF.Ptr M2.QAbstractAnimation -> HoppyP.IO ()
foreign import ccall "genpop__QAnimationGroup_animationAt" animationAt' ::  HoppyF.Ptr QAnimationGroupConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M2.QAbstractAnimation)
foreign import ccall "genpop__QAnimationGroup_animationCount" animationCount' ::  HoppyF.Ptr QAnimationGroupConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QAnimationGroup_clear" clear' ::  HoppyF.Ptr QAnimationGroup -> HoppyP.IO ()
foreign import ccall "genpop__QAnimationGroup_duration" duration' ::  HoppyF.Ptr QAnimationGroupConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QAnimationGroup_indexOfAnimation" indexOfAnimation' ::  HoppyF.Ptr QAnimationGroupConst -> HoppyF.Ptr M2.QAbstractAnimation -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QAnimationGroup_insertAnimation" insertAnimation' ::  HoppyF.Ptr QAnimationGroup -> HoppyFC.CInt -> HoppyF.Ptr M2.QAbstractAnimation -> HoppyP.IO ()
foreign import ccall "genpop__QAnimationGroup_removeAnimation" removeAnimation' ::  HoppyF.Ptr QAnimationGroup -> HoppyF.Ptr M2.QAbstractAnimation -> HoppyP.IO ()
foreign import ccall "genpop__QAnimationGroup_takeAnimation" takeAnimation' ::  HoppyF.Ptr QAnimationGroup -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M2.QAbstractAnimation)
foreign import ccall "gencast__QAnimationGroup__QAbstractAnimation" castQAnimationGroupToQAbstractAnimation :: HoppyF.Ptr QAnimationGroupConst -> HoppyF.Ptr M2.QAbstractAnimationConst
foreign import ccall "gencast__QAbstractAnimation__QAnimationGroup" castQAbstractAnimationToQAnimationGroup :: HoppyF.Ptr M2.QAbstractAnimationConst -> HoppyF.Ptr QAnimationGroupConst
foreign import ccall "gencast__QAnimationGroup__QObject" castQAnimationGroupToQObject :: HoppyF.Ptr QAnimationGroupConst -> HoppyF.Ptr M94.QObjectConst
foreign import ccall "gencast__QObject__QAnimationGroup" castQObjectToQAnimationGroup :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr QAnimationGroupConst
foreign import ccall "gendel__QAnimationGroup" delete'QAnimationGroup :: HoppyF.Ptr QAnimationGroupConst -> HoppyP.IO ()
foreign import ccall "&gendel__QAnimationGroup" deletePtr'QAnimationGroup :: HoppyF.FunPtr (HoppyF.Ptr QAnimationGroupConst -> HoppyP.IO ())

class QAnimationGroupValue a where
  withQAnimationGroupPtr :: a -> (QAnimationGroupConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QAnimationGroupConstPtr a => QAnimationGroupValue a where
  withQAnimationGroupPtr = HoppyP.flip ($) . toQAnimationGroupConst

class (M2.QAbstractAnimationConstPtr this) => QAnimationGroupConstPtr this where
  toQAnimationGroupConst :: this -> QAnimationGroupConst

animationAt :: (QAnimationGroupValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO M2.QAbstractAnimation)
animationAt arg'1 arg'2 =
  withQAnimationGroupPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap M2.QAbstractAnimation
  (animationAt' arg'1' arg'2')

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

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

indexOfAnimation :: (QAnimationGroupValue this, M2.QAbstractAnimationPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Int)
indexOfAnimation arg'1 arg'2 =
  withQAnimationGroupPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyFHR.withCppPtr (M2.toQAbstractAnimation arg'2) $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (indexOfAnimation' arg'1' arg'2')

class (QAnimationGroupConstPtr this, M2.QAbstractAnimationPtr this) => QAnimationGroupPtr this where
  toQAnimationGroup :: this -> QAnimationGroup

addAnimation :: (QAnimationGroupPtr this, M2.QAbstractAnimationPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
addAnimation arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQAnimationGroup arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M2.toQAbstractAnimation arg'2) $ \arg'2' ->
  (addAnimation' arg'1' arg'2')

clear :: (QAnimationGroupPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
clear arg'1 =
  HoppyFHR.withCppPtr (toQAnimationGroup arg'1) $ \arg'1' ->
  (clear' arg'1')

insertAnimation :: (QAnimationGroupPtr this, M2.QAbstractAnimationPtr arg'3) => (this) {- ^ this -} -> (HoppyP.Int) -> (arg'3) -> (HoppyP.IO ())
insertAnimation arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQAnimationGroup arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyFHR.withCppPtr (M2.toQAbstractAnimation arg'3) $ \arg'3' ->
  (insertAnimation' arg'1' arg'2' arg'3')

removeAnimation :: (QAnimationGroupPtr this, M2.QAbstractAnimationPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
removeAnimation arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQAnimationGroup arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M2.toQAbstractAnimation arg'2) $ \arg'2' ->
  (removeAnimation' arg'1' arg'2')

takeAnimation :: (QAnimationGroupPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO M2.QAbstractAnimation)
takeAnimation arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQAnimationGroup arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap M2.QAbstractAnimation
  (takeAnimation' arg'1' arg'2')

data QAnimationGroupConst =
    QAnimationGroupConst (HoppyF.Ptr QAnimationGroupConst)
  | QAnimationGroupConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QAnimationGroupConst)
  deriving (HoppyP.Show)

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

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

castQAnimationGroupToConst :: QAnimationGroup -> QAnimationGroupConst
castQAnimationGroupToConst (QAnimationGroup ptr') = QAnimationGroupConst $ HoppyF.castPtr ptr'
castQAnimationGroupToConst (QAnimationGroupGc fptr' ptr') = QAnimationGroupConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QAnimationGroupConstPtr QAnimationGroupConst where
  toQAnimationGroupConst = HoppyP.id

instance M2.QAbstractAnimationConstPtr QAnimationGroupConst where
  toQAbstractAnimationConst (QAnimationGroupConst ptr') = M2.QAbstractAnimationConst $ castQAnimationGroupToQAbstractAnimation ptr'
  toQAbstractAnimationConst (QAnimationGroupConstGc fptr' ptr') = M2.QAbstractAnimationConstGc fptr' $ castQAnimationGroupToQAbstractAnimation ptr'

instance M94.QObjectConstPtr QAnimationGroupConst where
  toQObjectConst (QAnimationGroupConst ptr') = M94.QObjectConst $ castQAnimationGroupToQObject ptr'
  toQObjectConst (QAnimationGroupConstGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQAnimationGroupToQObject ptr'

data QAnimationGroup =
    QAnimationGroup (HoppyF.Ptr QAnimationGroup)
  | QAnimationGroupGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QAnimationGroup)
  deriving (HoppyP.Show)

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

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

castQAnimationGroupToNonconst :: QAnimationGroupConst -> QAnimationGroup
castQAnimationGroupToNonconst (QAnimationGroupConst ptr') = QAnimationGroup $ HoppyF.castPtr ptr'
castQAnimationGroupToNonconst (QAnimationGroupConstGc fptr' ptr') = QAnimationGroupGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QAnimationGroupConstPtr QAnimationGroup where
  toQAnimationGroupConst (QAnimationGroup ptr') = QAnimationGroupConst $ (HoppyF.castPtr :: HoppyF.Ptr QAnimationGroup -> HoppyF.Ptr QAnimationGroupConst) ptr'
  toQAnimationGroupConst (QAnimationGroupGc fptr' ptr') = QAnimationGroupConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QAnimationGroup -> HoppyF.Ptr QAnimationGroupConst) ptr'

instance QAnimationGroupPtr QAnimationGroup where
  toQAnimationGroup = HoppyP.id

instance M2.QAbstractAnimationConstPtr QAnimationGroup where
  toQAbstractAnimationConst (QAnimationGroup ptr') = M2.QAbstractAnimationConst $ castQAnimationGroupToQAbstractAnimation $ (HoppyF.castPtr :: HoppyF.Ptr QAnimationGroup -> HoppyF.Ptr QAnimationGroupConst) ptr'
  toQAbstractAnimationConst (QAnimationGroupGc fptr' ptr') = M2.QAbstractAnimationConstGc fptr' $ castQAnimationGroupToQAbstractAnimation $ (HoppyF.castPtr :: HoppyF.Ptr QAnimationGroup -> HoppyF.Ptr QAnimationGroupConst) ptr'

instance M2.QAbstractAnimationPtr QAnimationGroup where
  toQAbstractAnimation (QAnimationGroup ptr') = M2.QAbstractAnimation $ (HoppyF.castPtr :: HoppyF.Ptr M2.QAbstractAnimationConst -> HoppyF.Ptr M2.QAbstractAnimation) $ castQAnimationGroupToQAbstractAnimation $ (HoppyF.castPtr :: HoppyF.Ptr QAnimationGroup -> HoppyF.Ptr QAnimationGroupConst) ptr'
  toQAbstractAnimation (QAnimationGroupGc fptr' ptr') = M2.QAbstractAnimationGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M2.QAbstractAnimationConst -> HoppyF.Ptr M2.QAbstractAnimation) $ castQAnimationGroupToQAbstractAnimation $ (HoppyF.castPtr :: HoppyF.Ptr QAnimationGroup -> HoppyF.Ptr QAnimationGroupConst) ptr'

instance M94.QObjectConstPtr QAnimationGroup where
  toQObjectConst (QAnimationGroup ptr') = M94.QObjectConst $ castQAnimationGroupToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QAnimationGroup -> HoppyF.Ptr QAnimationGroupConst) ptr'
  toQObjectConst (QAnimationGroupGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQAnimationGroupToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QAnimationGroup -> HoppyF.Ptr QAnimationGroupConst) ptr'

instance M94.QObjectPtr QAnimationGroup where
  toQObject (QAnimationGroup ptr') = M94.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQAnimationGroupToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QAnimationGroup -> HoppyF.Ptr QAnimationGroupConst) ptr'
  toQObject (QAnimationGroupGc fptr' ptr') = M94.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQAnimationGroupToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QAnimationGroup -> HoppyF.Ptr QAnimationGroupConst) ptr'

class QAnimationGroupSuper a where
  downToQAnimationGroup :: a -> QAnimationGroup

instance QAnimationGroupSuper M2.QAbstractAnimation where
  downToQAnimationGroup = castQAnimationGroupToNonconst . cast' . M2.castQAbstractAnimationToConst
    where
      cast' (M2.QAbstractAnimationConst ptr') = QAnimationGroupConst $ castQAbstractAnimationToQAnimationGroup ptr'
      cast' (M2.QAbstractAnimationConstGc fptr' ptr') = QAnimationGroupConstGc fptr' $ castQAbstractAnimationToQAnimationGroup ptr'
instance QAnimationGroupSuper M94.QObject where
  downToQAnimationGroup = castQAnimationGroupToNonconst . cast' . M94.castQObjectToConst
    where
      cast' (M94.QObjectConst ptr') = QAnimationGroupConst $ castQObjectToQAnimationGroup ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QAnimationGroupConstGc fptr' $ castQObjectToQAnimationGroup ptr'

class QAnimationGroupSuperConst a where
  downToQAnimationGroupConst :: a -> QAnimationGroupConst

instance QAnimationGroupSuperConst M2.QAbstractAnimationConst where
  downToQAnimationGroupConst = cast'
    where
      cast' (M2.QAbstractAnimationConst ptr') = QAnimationGroupConst $ castQAbstractAnimationToQAnimationGroup ptr'
      cast' (M2.QAbstractAnimationConstGc fptr' ptr') = QAnimationGroupConstGc fptr' $ castQAbstractAnimationToQAnimationGroup ptr'
instance QAnimationGroupSuperConst M94.QObjectConst where
  downToQAnimationGroupConst = cast'
    where
      cast' (M94.QObjectConst ptr') = QAnimationGroupConst $ castQObjectToQAnimationGroup ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QAnimationGroupConstGc fptr' $ castQObjectToQAnimationGroup ptr'

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

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