QAbstractAnimation.hs

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

module Graphics.UI.Qtah.Generated.Core.QAbstractAnimation (
  castQAbstractAnimationToQObject,
  castQObjectToQAbstractAnimation,
  QAbstractAnimationValue (..),
  QAbstractAnimationConstPtr (..),
  currentLoopTime,
  duration,
  totalDuration,
  QAbstractAnimationPtr (..),
  pause,
  resume,
  setPaused,
  start,
  startWithDeletionPolicy,
  stop,
  emitCurrentLoopChanged,
  emitDirectionChanged,
  emitFinished,
  emitStateChanged,
  QAbstractAnimationConst (..),
  castQAbstractAnimationToConst,
  QAbstractAnimation (..),
  castQAbstractAnimationToNonconst,
  QAbstractAnimationSuper (..),
  QAbstractAnimationSuperConst (..),
  QAbstractAnimationDeletionPolicy (..),
  QAbstractAnimationDirection (..),
  QAbstractAnimationState (..),
  ) 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 Prelude (($), (.), (=<<), (==), (>>=))
import qualified Prelude as HoppyP

foreign import ccall "genpop__QAbstractAnimation_currentLoopTime" currentLoopTime' ::  HoppyF.Ptr QAbstractAnimationConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QAbstractAnimation_duration" duration' ::  HoppyF.Ptr QAbstractAnimationConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QAbstractAnimation_pause" pause' ::  HoppyF.Ptr QAbstractAnimation -> HoppyP.IO ()
foreign import ccall "genpop__QAbstractAnimation_resume" resume' ::  HoppyF.Ptr QAbstractAnimation -> HoppyP.IO ()
foreign import ccall "genpop__QAbstractAnimation_setPaused" setPaused' ::  HoppyF.Ptr QAbstractAnimation -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QAbstractAnimation_start" start' ::  HoppyF.Ptr QAbstractAnimation -> HoppyP.IO ()
foreign import ccall "genpop__QAbstractAnimation_startWithDeletionPolicy" startWithDeletionPolicy' ::  HoppyF.Ptr QAbstractAnimation -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QAbstractAnimation_stop" stop' ::  HoppyF.Ptr QAbstractAnimation -> HoppyP.IO ()
foreign import ccall "genpop__QAbstractAnimation_totalDuration" totalDuration' ::  HoppyF.Ptr QAbstractAnimationConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QAbstractAnimation_emitCurrentLoopChanged" emitCurrentLoopChanged' ::  HoppyF.Ptr QAbstractAnimation -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QAbstractAnimation_emitDirectionChanged" emitDirectionChanged' ::  HoppyF.Ptr QAbstractAnimation -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QAbstractAnimation_emitFinished" emitFinished' ::  HoppyF.Ptr QAbstractAnimation -> HoppyP.IO ()
foreign import ccall "genpop__QAbstractAnimation_emitStateChanged" emitStateChanged' ::  HoppyF.Ptr QAbstractAnimation -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "gencast__QAbstractAnimation__QObject" castQAbstractAnimationToQObject :: HoppyF.Ptr QAbstractAnimationConst -> HoppyF.Ptr M94.QObjectConst
foreign import ccall "gencast__QObject__QAbstractAnimation" castQObjectToQAbstractAnimation :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr QAbstractAnimationConst
foreign import ccall "gendel__QAbstractAnimation" delete'QAbstractAnimation :: HoppyF.Ptr QAbstractAnimationConst -> HoppyP.IO ()
foreign import ccall "&gendel__QAbstractAnimation" deletePtr'QAbstractAnimation :: HoppyF.FunPtr (HoppyF.Ptr QAbstractAnimationConst -> HoppyP.IO ())

class QAbstractAnimationValue a where
  withQAbstractAnimationPtr :: a -> (QAbstractAnimationConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QAbstractAnimationConstPtr a => QAbstractAnimationValue a where
  withQAbstractAnimationPtr = HoppyP.flip ($) . toQAbstractAnimationConst

class (M94.QObjectConstPtr this) => QAbstractAnimationConstPtr this where
  toQAbstractAnimationConst :: this -> QAbstractAnimationConst

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

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

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

class (QAbstractAnimationConstPtr this, M94.QObjectPtr this) => QAbstractAnimationPtr this where
  toQAbstractAnimation :: this -> QAbstractAnimation

pause :: (QAbstractAnimationPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
pause arg'1 =
  HoppyFHR.withCppPtr (toQAbstractAnimation arg'1) $ \arg'1' ->
  (pause' arg'1')

resume :: (QAbstractAnimationPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
resume arg'1 =
  HoppyFHR.withCppPtr (toQAbstractAnimation arg'1) $ \arg'1' ->
  (resume' arg'1')

setPaused :: (QAbstractAnimationPtr this) => (this) {- ^ this -} -> (HoppyP.Bool) -> (HoppyP.IO ())
setPaused arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQAbstractAnimation arg'1) $ \arg'1' ->
  (
    \x -> HoppyP.return $ if x then 1 else 0
  ) arg'2 >>= \arg'2' ->
  (setPaused' arg'1' arg'2')

start :: (QAbstractAnimationPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
start arg'1 =
  HoppyFHR.withCppPtr (toQAbstractAnimation arg'1) $ \arg'1' ->
  (start' arg'1')

startWithDeletionPolicy :: (QAbstractAnimationPtr this) => (this) {- ^ this -} -> (QAbstractAnimationDeletionPolicy) -> (HoppyP.IO ())
startWithDeletionPolicy arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQAbstractAnimation arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (startWithDeletionPolicy' arg'1' arg'2')

stop :: (QAbstractAnimationPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
stop arg'1 =
  HoppyFHR.withCppPtr (toQAbstractAnimation arg'1) $ \arg'1' ->
  (stop' arg'1')

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

emitDirectionChanged :: (QAbstractAnimationPtr this) => (this) {- ^ this -} -> (QAbstractAnimationDirection) -> (HoppyP.IO ())
emitDirectionChanged arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQAbstractAnimation arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (emitDirectionChanged' arg'1' arg'2')

emitFinished :: (QAbstractAnimationPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
emitFinished arg'1 =
  HoppyFHR.withCppPtr (toQAbstractAnimation arg'1) $ \arg'1' ->
  (emitFinished' arg'1')

emitStateChanged :: (QAbstractAnimationPtr this) => (this) {- ^ this -} -> (QAbstractAnimationState) -> (QAbstractAnimationState) -> (HoppyP.IO ())
emitStateChanged arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQAbstractAnimation arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'3 >>= \arg'3' ->
  (emitStateChanged' arg'1' arg'2' arg'3')

data QAbstractAnimationConst =
    QAbstractAnimationConst (HoppyF.Ptr QAbstractAnimationConst)
  | QAbstractAnimationConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QAbstractAnimationConst)
  deriving (HoppyP.Show)

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

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

castQAbstractAnimationToConst :: QAbstractAnimation -> QAbstractAnimationConst
castQAbstractAnimationToConst (QAbstractAnimation ptr') = QAbstractAnimationConst $ HoppyF.castPtr ptr'
castQAbstractAnimationToConst (QAbstractAnimationGc fptr' ptr') = QAbstractAnimationConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QAbstractAnimationConstPtr QAbstractAnimationConst where
  toQAbstractAnimationConst = HoppyP.id

instance M94.QObjectConstPtr QAbstractAnimationConst where
  toQObjectConst (QAbstractAnimationConst ptr') = M94.QObjectConst $ castQAbstractAnimationToQObject ptr'
  toQObjectConst (QAbstractAnimationConstGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQAbstractAnimationToQObject ptr'

data QAbstractAnimation =
    QAbstractAnimation (HoppyF.Ptr QAbstractAnimation)
  | QAbstractAnimationGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QAbstractAnimation)
  deriving (HoppyP.Show)

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

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

castQAbstractAnimationToNonconst :: QAbstractAnimationConst -> QAbstractAnimation
castQAbstractAnimationToNonconst (QAbstractAnimationConst ptr') = QAbstractAnimation $ HoppyF.castPtr ptr'
castQAbstractAnimationToNonconst (QAbstractAnimationConstGc fptr' ptr') = QAbstractAnimationGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QAbstractAnimationConstPtr QAbstractAnimation where
  toQAbstractAnimationConst (QAbstractAnimation ptr') = QAbstractAnimationConst $ (HoppyF.castPtr :: HoppyF.Ptr QAbstractAnimation -> HoppyF.Ptr QAbstractAnimationConst) ptr'
  toQAbstractAnimationConst (QAbstractAnimationGc fptr' ptr') = QAbstractAnimationConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QAbstractAnimation -> HoppyF.Ptr QAbstractAnimationConst) ptr'

instance QAbstractAnimationPtr QAbstractAnimation where
  toQAbstractAnimation = HoppyP.id

instance M94.QObjectConstPtr QAbstractAnimation where
  toQObjectConst (QAbstractAnimation ptr') = M94.QObjectConst $ castQAbstractAnimationToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QAbstractAnimation -> HoppyF.Ptr QAbstractAnimationConst) ptr'
  toQObjectConst (QAbstractAnimationGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQAbstractAnimationToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QAbstractAnimation -> HoppyF.Ptr QAbstractAnimationConst) ptr'

instance M94.QObjectPtr QAbstractAnimation where
  toQObject (QAbstractAnimation ptr') = M94.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQAbstractAnimationToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QAbstractAnimation -> HoppyF.Ptr QAbstractAnimationConst) ptr'
  toQObject (QAbstractAnimationGc fptr' ptr') = M94.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQAbstractAnimationToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QAbstractAnimation -> HoppyF.Ptr QAbstractAnimationConst) ptr'

class QAbstractAnimationSuper a where
  downToQAbstractAnimation :: a -> QAbstractAnimation

instance QAbstractAnimationSuper M94.QObject where
  downToQAbstractAnimation = castQAbstractAnimationToNonconst . cast' . M94.castQObjectToConst
    where
      cast' (M94.QObjectConst ptr') = QAbstractAnimationConst $ castQObjectToQAbstractAnimation ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QAbstractAnimationConstGc fptr' $ castQObjectToQAbstractAnimation ptr'

class QAbstractAnimationSuperConst a where
  downToQAbstractAnimationConst :: a -> QAbstractAnimationConst

instance QAbstractAnimationSuperConst M94.QObjectConst where
  downToQAbstractAnimationConst = cast'
    where
      cast' (M94.QObjectConst ptr') = QAbstractAnimationConst $ castQObjectToQAbstractAnimation ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QAbstractAnimationConstGc fptr' $ castQObjectToQAbstractAnimation ptr'

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

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

data QAbstractAnimationDeletionPolicy =
  KeepWhenStopped
  | DeleteWhenStopped
  | UnknownQAbstractAnimationDeletionPolicy (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QAbstractAnimationDeletionPolicy where
  fromCppEnum KeepWhenStopped = 0
  fromCppEnum DeleteWhenStopped = 1
  fromCppEnum (UnknownQAbstractAnimationDeletionPolicy n) = n
  
  toCppEnum (0) = KeepWhenStopped
  toCppEnum (1) = DeleteWhenStopped
  toCppEnum n = UnknownQAbstractAnimationDeletionPolicy n

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

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

data QAbstractAnimationDirection =
  Forward
  | Backward
  | UnknownQAbstractAnimationDirection (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QAbstractAnimationDirection where
  fromCppEnum Forward = 0
  fromCppEnum Backward = 1
  fromCppEnum (UnknownQAbstractAnimationDirection n) = n
  
  toCppEnum (0) = Forward
  toCppEnum (1) = Backward
  toCppEnum n = UnknownQAbstractAnimationDirection n

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

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

data QAbstractAnimationState =
  Stopped
  | Paused
  | Running
  | UnknownQAbstractAnimationState (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QAbstractAnimationState where
  fromCppEnum Stopped = 0
  fromCppEnum Paused = 1
  fromCppEnum Running = 2
  fromCppEnum (UnknownQAbstractAnimationState n) = n
  
  toCppEnum (0) = Stopped
  toCppEnum (1) = Paused
  toCppEnum (2) = Running
  toCppEnum n = UnknownQAbstractAnimationState n

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

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