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

module Graphics.UI.Qtah.Generated.Core.QLoggingCategory (
  QLoggingCategoryValue (..),
  QLoggingCategoryConstPtr (..),
  categoryName,
  isCriticalEnabled,
  isDebugEnabled,
  isEnabled,
  isInfoEnabled,
  isWarningEnabled,
  QLoggingCategoryPtr (..),
  setEnabled,
  defaultCategory,
  installFilter,
  setFilterRules,
  QLoggingCategoryConst (..),
  castQLoggingCategoryToConst,
  QLoggingCategory (..),
  castQLoggingCategoryToNonconst,
  newWithMsgType,
  new,
  QLoggingCategorySuper (..),
  QLoggingCategorySuperConst (..),
  ) 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.QString as M142
import qualified Graphics.UI.Qtah.Generated.Core.Types as M190
import Prelude (($), (.), (/=), (=<<), (==), (>>=))
import qualified Prelude as HoppyP

foreign import ccall "genpop__QLoggingCategory_newWithMsgType" newWithMsgType' ::  HoppyF.Ptr HoppyFC.CChar -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QLoggingCategory)
foreign import ccall "genpop__QLoggingCategory_new" new' ::  HoppyF.Ptr HoppyFC.CChar -> HoppyP.IO (HoppyF.Ptr QLoggingCategory)
foreign import ccall "genpop__QLoggingCategory_categoryName" categoryName' ::  HoppyF.Ptr QLoggingCategoryConst -> HoppyP.IO (HoppyF.Ptr HoppyFC.CChar)
foreign import ccall "genpop__QLoggingCategory_defaultCategory" defaultCategory' ::  HoppyP.IO (HoppyF.Ptr QLoggingCategory)
foreign import ccall "genpop__QLoggingCategory_installFilter" installFilter' ::  HoppyF.FunPtr (HoppyF.Ptr QLoggingCategory -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr QLoggingCategory -> HoppyP.IO ()))
foreign import ccall "genpop__QLoggingCategory_isCriticalEnabled" isCriticalEnabled' ::  HoppyF.Ptr QLoggingCategoryConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLoggingCategory_isDebugEnabled" isDebugEnabled' ::  HoppyF.Ptr QLoggingCategoryConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLoggingCategory_isEnabled" isEnabled' ::  HoppyF.Ptr QLoggingCategoryConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLoggingCategory_isInfoEnabled" isInfoEnabled' ::  HoppyF.Ptr QLoggingCategoryConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLoggingCategory_isWarningEnabled" isWarningEnabled' ::  HoppyF.Ptr QLoggingCategoryConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLoggingCategory_setEnabled" setEnabled' ::  HoppyF.Ptr QLoggingCategory -> HoppyFC.CInt -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QLoggingCategory_setFilterRules" setFilterRules' ::  HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "gendel__QLoggingCategory" delete'QLoggingCategory :: HoppyF.Ptr QLoggingCategoryConst -> HoppyP.IO ()
foreign import ccall "&gendel__QLoggingCategory" deletePtr'QLoggingCategory :: HoppyF.FunPtr (HoppyF.Ptr QLoggingCategoryConst -> HoppyP.IO ())

class QLoggingCategoryValue a where
  withQLoggingCategoryPtr :: a -> (QLoggingCategoryConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QLoggingCategoryConstPtr a => QLoggingCategoryValue a where
  withQLoggingCategoryPtr = HoppyP.flip ($) . toQLoggingCategoryConst

class (HoppyFHR.CppPtr this) => QLoggingCategoryConstPtr this where
  toQLoggingCategoryConst :: this -> QLoggingCategoryConst

categoryName :: (QLoggingCategoryValue this) => (this) {- ^ this -} -> (HoppyP.IO (HoppyF.Ptr HoppyFC.CChar))
categoryName arg'1 =
  withQLoggingCategoryPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (categoryName' arg'1')

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

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

isEnabled :: (QLoggingCategoryValue this) => (this) {- ^ this -} -> (M190.QtMsgType) -> (HoppyP.IO HoppyP.Bool)
isEnabled arg'1 arg'2 =
  withQLoggingCategoryPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isEnabled' arg'1' arg'2')

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

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

class (QLoggingCategoryConstPtr this) => QLoggingCategoryPtr this where
  toQLoggingCategory :: this -> QLoggingCategory

setEnabled :: (QLoggingCategoryPtr this) => (this) {- ^ this -} -> (M190.QtMsgType) -> (HoppyP.Bool) -> (HoppyP.IO ())
setEnabled arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQLoggingCategory arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (
    \x -> HoppyP.return $ if x then 1 else 0
  ) arg'3 >>= \arg'3' ->
  (setEnabled' arg'1' arg'2' arg'3')

defaultCategory :: (HoppyP.IO QLoggingCategory)
defaultCategory =
  HoppyP.fmap QLoggingCategory
  (defaultCategory')

installFilter :: (HoppyF.FunPtr (HoppyF.Ptr QLoggingCategory -> HoppyP.IO ())) -> (HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr QLoggingCategory -> HoppyP.IO ())))
installFilter arg'1 =
  let arg'1' = arg'1 in
  (installFilter' arg'1')

setFilterRules :: (M142.QStringValue arg'1) => (arg'1) -> (HoppyP.IO ())
setFilterRules arg'1 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (setFilterRules' arg'1')

data QLoggingCategoryConst =
    QLoggingCategoryConst (HoppyF.Ptr QLoggingCategoryConst)
  | QLoggingCategoryConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QLoggingCategoryConst)
  deriving (HoppyP.Show)

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

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

castQLoggingCategoryToConst :: QLoggingCategory -> QLoggingCategoryConst
castQLoggingCategoryToConst (QLoggingCategory ptr') = QLoggingCategoryConst $ HoppyF.castPtr ptr'
castQLoggingCategoryToConst (QLoggingCategoryGc fptr' ptr') = QLoggingCategoryConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QLoggingCategoryConstPtr QLoggingCategoryConst where
  toQLoggingCategoryConst = HoppyP.id

data QLoggingCategory =
    QLoggingCategory (HoppyF.Ptr QLoggingCategory)
  | QLoggingCategoryGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QLoggingCategory)
  deriving (HoppyP.Show)

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

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

castQLoggingCategoryToNonconst :: QLoggingCategoryConst -> QLoggingCategory
castQLoggingCategoryToNonconst (QLoggingCategoryConst ptr') = QLoggingCategory $ HoppyF.castPtr ptr'
castQLoggingCategoryToNonconst (QLoggingCategoryConstGc fptr' ptr') = QLoggingCategoryGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QLoggingCategoryConstPtr QLoggingCategory where
  toQLoggingCategoryConst (QLoggingCategory ptr') = QLoggingCategoryConst $ (HoppyF.castPtr :: HoppyF.Ptr QLoggingCategory -> HoppyF.Ptr QLoggingCategoryConst) ptr'
  toQLoggingCategoryConst (QLoggingCategoryGc fptr' ptr') = QLoggingCategoryConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QLoggingCategory -> HoppyF.Ptr QLoggingCategoryConst) ptr'

instance QLoggingCategoryPtr QLoggingCategory where
  toQLoggingCategory = HoppyP.id

newWithMsgType :: (HoppyF.Ptr HoppyFC.CChar) -> (M190.QtMsgType) -> (HoppyP.IO QLoggingCategory)
newWithMsgType arg'1 arg'2 =
  let arg'1' = arg'1 in
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap QLoggingCategory
  (newWithMsgType' arg'1' arg'2')

new :: (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.IO QLoggingCategory)
new arg'1 =
  let arg'1' = arg'1 in
  HoppyP.fmap QLoggingCategory
  (new' arg'1')

class QLoggingCategorySuper a where
  downToQLoggingCategory :: a -> QLoggingCategory


class QLoggingCategorySuperConst a where
  downToQLoggingCategoryConst :: a -> QLoggingCategoryConst


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

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