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

module Graphics.UI.Qtah.Generated.Core.QThread (
  castQThreadToQObject,
  castQObjectToQThread,
  QThreadValue (..),
  QThreadConstPtr (..),
  isFinished,
  isInterruptionRequested,
  isRunning,
  loopLevel,
  priority,
  stackSize,
  QThreadPtr (..),
  exit,
  exitWithCode,
  setPriority,
  quit,
  requestInterruption,
  setStackSize,
  start,
  startWithPriority,
  terminate,
  wait,
  waitWithMillis,
  currentThread,
  idealThreadCount,
  msleep,
  sleep,
  usleep,
  yieldCurrentThread,
  QThreadConst (..),
  castQThreadToConst,
  QThread (..),
  castQThreadToNonconst,
  new,
  newWithParent,
  QThreadSuper (..),
  QThreadSuperConst (..),
  QThreadPriority (..),
  ) where

import qualified Foreign as HoppyF
import qualified Foreign.C as HoppyFC
import qualified Foreign.Hoppy.Runtime as HoppyFHR
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Core.QObject as M94
import Prelude (($), (.), (/=), (=<<), (==), (>>=))
import qualified Prelude as HoppyP

foreign import ccall "genpop__QThread_new" new' ::  HoppyP.IO (HoppyF.Ptr QThread)
foreign import ccall "genpop__QThread_newWithParent" newWithParent' ::  HoppyF.Ptr M94.QObject -> HoppyP.IO (HoppyF.Ptr QThread)
foreign import ccall "genpop__QThread_exit" exit' ::  HoppyF.Ptr QThread -> HoppyP.IO ()
foreign import ccall "genpop__QThread_exitWithCode" exitWithCode' ::  HoppyF.Ptr QThread -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QThread_isFinished" isFinished' ::  HoppyF.Ptr QThreadConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QThread_isInterruptionRequested" isInterruptionRequested' ::  HoppyF.Ptr QThreadConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QThread_isRunning" isRunning' ::  HoppyF.Ptr QThreadConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QThread_loopLevel" loopLevel' ::  HoppyF.Ptr QThreadConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QThread_priority" priority' ::  HoppyF.Ptr QThreadConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QThread_setPriority" setPriority' ::  HoppyF.Ptr QThread -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QThread_quit" quit' ::  HoppyF.Ptr QThread -> HoppyP.IO ()
foreign import ccall "genpop__QThread_requestInterruption" requestInterruption' ::  HoppyF.Ptr QThread -> HoppyP.IO ()
foreign import ccall "genpop__QThread_stackSize" stackSize' ::  HoppyF.Ptr QThreadConst -> HoppyP.IO HoppyFC.CUInt
foreign import ccall "genpop__QThread_setStackSize" setStackSize' ::  HoppyF.Ptr QThread -> HoppyFC.CUInt -> HoppyP.IO ()
foreign import ccall "genpop__QThread_start" start' ::  HoppyF.Ptr QThread -> HoppyP.IO ()
foreign import ccall "genpop__QThread_startWithPriority" startWithPriority' ::  HoppyF.Ptr QThread -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QThread_terminate" terminate' ::  HoppyF.Ptr QThread -> HoppyP.IO ()
foreign import ccall "genpop__QThread_wait" wait' ::  HoppyF.Ptr QThread -> HoppyP.IO ()
foreign import ccall "genpop__QThread_waitWithMillis" waitWithMillis' ::  HoppyF.Ptr QThread -> HoppyFC.CULong -> HoppyP.IO ()
foreign import ccall "genpop__QThread_currentThread" currentThread' ::  HoppyP.IO (HoppyF.Ptr QThread)
foreign import ccall "genpop__QThread_idealThreadCount" idealThreadCount' ::  HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QThread_msleep" msleep' ::  HoppyFC.CULong -> HoppyP.IO ()
foreign import ccall "genpop__QThread_sleep" sleep' ::  HoppyFC.CULong -> HoppyP.IO ()
foreign import ccall "genpop__QThread_usleep" usleep' ::  HoppyFC.CULong -> HoppyP.IO ()
foreign import ccall "genpop__QThread_yieldCurrentThread" yieldCurrentThread' ::  HoppyP.IO ()
foreign import ccall "gencast__QThread__QObject" castQThreadToQObject :: HoppyF.Ptr QThreadConst -> HoppyF.Ptr M94.QObjectConst
foreign import ccall "gencast__QObject__QThread" castQObjectToQThread :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr QThreadConst
foreign import ccall "gendel__QThread" delete'QThread :: HoppyF.Ptr QThreadConst -> HoppyP.IO ()
foreign import ccall "&gendel__QThread" deletePtr'QThread :: HoppyF.FunPtr (HoppyF.Ptr QThreadConst -> HoppyP.IO ())

class QThreadValue a where
  withQThreadPtr :: a -> (QThreadConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QThreadConstPtr a => QThreadValue a where
  withQThreadPtr = HoppyP.flip ($) . toQThreadConst

class (M94.QObjectConstPtr this) => QThreadConstPtr this where
  toQThreadConst :: this -> QThreadConst

isFinished :: (QThreadValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Bool)
isFinished arg'1 =
  withQThreadPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isFinished' arg'1')

isInterruptionRequested :: (QThreadValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Bool)
isInterruptionRequested arg'1 =
  withQThreadPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isInterruptionRequested' arg'1')

isRunning :: (QThreadValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Bool)
isRunning arg'1 =
  withQThreadPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isRunning' arg'1')

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

priority :: (QThreadValue this) => (this) {- ^ this -} -> (HoppyP.IO QThreadPriority)
priority arg'1 =
  withQThreadPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (priority' arg'1')

stackSize :: (QThreadValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyFC.CUInt)
stackSize arg'1 =
  withQThreadPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (stackSize' arg'1')

class (QThreadConstPtr this, M94.QObjectPtr this) => QThreadPtr this where
  toQThread :: this -> QThread

exit :: (QThreadPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
exit arg'1 =
  HoppyFHR.withCppPtr (toQThread arg'1) $ \arg'1' ->
  (exit' arg'1')

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

setPriority :: (QThreadPtr this) => (this) {- ^ this -} -> (QThreadPriority) -> (HoppyP.IO ())
setPriority arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQThread arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (setPriority' arg'1' arg'2')

quit :: (QThreadPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
quit arg'1 =
  HoppyFHR.withCppPtr (toQThread arg'1) $ \arg'1' ->
  (quit' arg'1')

requestInterruption :: (QThreadPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
requestInterruption arg'1 =
  HoppyFHR.withCppPtr (toQThread arg'1) $ \arg'1' ->
  (requestInterruption' arg'1')

setStackSize :: (QThreadPtr this) => (this) {- ^ this -} -> (HoppyFC.CUInt) -> (HoppyP.IO ())
setStackSize arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQThread arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  (setStackSize' arg'1' arg'2')

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

startWithPriority :: (QThreadPtr this) => (this) {- ^ this -} -> (QThreadPriority) -> (HoppyP.IO ())
startWithPriority arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQThread arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (startWithPriority' arg'1' arg'2')

terminate :: (QThreadPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
terminate arg'1 =
  HoppyFHR.withCppPtr (toQThread arg'1) $ \arg'1' ->
  (terminate' arg'1')

wait :: (QThreadPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
wait arg'1 =
  HoppyFHR.withCppPtr (toQThread arg'1) $ \arg'1' ->
  (wait' arg'1')

waitWithMillis :: (QThreadPtr this) => (this) {- ^ this -} -> (HoppyFC.CULong) -> (HoppyP.IO ())
waitWithMillis arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQThread arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  (waitWithMillis' arg'1' arg'2')

currentThread :: (HoppyP.IO QThread)
currentThread =
  HoppyP.fmap QThread
  (currentThread')

idealThreadCount :: (HoppyP.IO HoppyP.Int)
idealThreadCount =
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (idealThreadCount')

msleep :: (HoppyFC.CULong) -> (HoppyP.IO ())
msleep arg'1 =
  let arg'1' = arg'1 in
  (msleep' arg'1')

sleep :: (HoppyFC.CULong) -> (HoppyP.IO ())
sleep arg'1 =
  let arg'1' = arg'1 in
  (sleep' arg'1')

usleep :: (HoppyFC.CULong) -> (HoppyP.IO ())
usleep arg'1 =
  let arg'1' = arg'1 in
  (usleep' arg'1')

yieldCurrentThread :: (HoppyP.IO ())
yieldCurrentThread =
  (yieldCurrentThread')

data QThreadConst =
    QThreadConst (HoppyF.Ptr QThreadConst)
  | QThreadConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QThreadConst)
  deriving (HoppyP.Show)

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

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

castQThreadToConst :: QThread -> QThreadConst
castQThreadToConst (QThread ptr') = QThreadConst $ HoppyF.castPtr ptr'
castQThreadToConst (QThreadGc fptr' ptr') = QThreadConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QThreadConstPtr QThreadConst where
  toQThreadConst = HoppyP.id

instance M94.QObjectConstPtr QThreadConst where
  toQObjectConst (QThreadConst ptr') = M94.QObjectConst $ castQThreadToQObject ptr'
  toQObjectConst (QThreadConstGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQThreadToQObject ptr'

data QThread =
    QThread (HoppyF.Ptr QThread)
  | QThreadGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QThread)
  deriving (HoppyP.Show)

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

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

castQThreadToNonconst :: QThreadConst -> QThread
castQThreadToNonconst (QThreadConst ptr') = QThread $ HoppyF.castPtr ptr'
castQThreadToNonconst (QThreadConstGc fptr' ptr') = QThreadGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QThreadConstPtr QThread where
  toQThreadConst (QThread ptr') = QThreadConst $ (HoppyF.castPtr :: HoppyF.Ptr QThread -> HoppyF.Ptr QThreadConst) ptr'
  toQThreadConst (QThreadGc fptr' ptr') = QThreadConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QThread -> HoppyF.Ptr QThreadConst) ptr'

instance QThreadPtr QThread where
  toQThread = HoppyP.id

instance M94.QObjectConstPtr QThread where
  toQObjectConst (QThread ptr') = M94.QObjectConst $ castQThreadToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QThread -> HoppyF.Ptr QThreadConst) ptr'
  toQObjectConst (QThreadGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQThreadToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QThread -> HoppyF.Ptr QThreadConst) ptr'

instance M94.QObjectPtr QThread where
  toQObject (QThread ptr') = M94.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQThreadToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QThread -> HoppyF.Ptr QThreadConst) ptr'
  toQObject (QThreadGc fptr' ptr') = M94.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQThreadToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QThread -> HoppyF.Ptr QThreadConst) ptr'

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

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

class QThreadSuper a where
  downToQThread :: a -> QThread

instance QThreadSuper M94.QObject where
  downToQThread = castQThreadToNonconst . cast' . M94.castQObjectToConst
    where
      cast' (M94.QObjectConst ptr') = QThreadConst $ castQObjectToQThread ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QThreadConstGc fptr' $ castQObjectToQThread ptr'

class QThreadSuperConst a where
  downToQThreadConst :: a -> QThreadConst

instance QThreadSuperConst M94.QObjectConst where
  downToQThreadConst = cast'
    where
      cast' (M94.QObjectConst ptr') = QThreadConst $ castQObjectToQThread ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QThreadConstGc fptr' $ castQObjectToQThread ptr'

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

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

data QThreadPriority =
  IdlePriority
  | LowestPriority
  | LowPriority
  | NormalPriority
  | HighPriority
  | HighestPriority
  | TimeCriticalPriority
  | InheritPriority
  | UnknownQThreadPriority (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QThreadPriority where
  fromCppEnum IdlePriority = 0
  fromCppEnum LowestPriority = 1
  fromCppEnum LowPriority = 2
  fromCppEnum NormalPriority = 3
  fromCppEnum HighPriority = 4
  fromCppEnum HighestPriority = 5
  fromCppEnum TimeCriticalPriority = 6
  fromCppEnum InheritPriority = 7
  fromCppEnum (UnknownQThreadPriority n) = n
  
  toCppEnum (0) = IdlePriority
  toCppEnum (1) = LowestPriority
  toCppEnum (2) = LowPriority
  toCppEnum (3) = NormalPriority
  toCppEnum (4) = HighPriority
  toCppEnum (5) = HighestPriority
  toCppEnum (6) = TimeCriticalPriority
  toCppEnum (7) = InheritPriority
  toCppEnum n = UnknownQThreadPriority n

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

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