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

module Graphics.UI.Qtah.Generated.Core.QStandardPaths (
  QStandardPathsValue (..),
  QStandardPathsConstPtr (..),
  QStandardPathsPtr (..),
  displayName,
  findExecutable,
  findExecutableWithPaths,
  locate,
  locateWithOptions,
  locateAll,
  locateAllWithOptions,
  setTestModeEnabled,
  standardLocations,
  writableLocation,
  QStandardPathsConst (..),
  castQStandardPathsToConst,
  QStandardPaths (..),
  castQStandardPathsToNonconst,
  QStandardPathsSuper (..),
  QStandardPathsSuperConst (..),
  QStandardPathsLocateOption (..),
  QStandardPathsLocateOptions,
  IsQStandardPathsLocateOptions (..),
  locateDirectory,
  locateFile,
  QStandardPathsStandardLocation (..),
  ) where

import Data.Bits ((.&.), (.|.))
import qualified Data.Bits as QtahDB
import qualified Foreign as HoppyF
import qualified Foreign.C as HoppyFC
import qualified Foreign.Hoppy.Runtime as HoppyFHR
import qualified Foreign.Hoppy.Runtime as QtahFHR
import qualified Graphics.UI.Qtah.Flags as QtahFlags
import qualified Graphics.UI.Qtah.Generated.Core.QString as M142
import qualified Graphics.UI.Qtah.Generated.Core.QStringList as M144
import Prelude (($), (.), (=<<), (==), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QStandardPaths_displayName" displayName' ::  HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QStandardPaths_findExecutable" findExecutable' ::  HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QStandardPaths_findExecutableWithPaths" findExecutableWithPaths' ::  HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M144.QStringListConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QStandardPaths_locate" locate' ::  HoppyFC.CInt -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QStandardPaths_locateWithOptions" locateWithOptions' ::  HoppyFC.CInt -> HoppyF.Ptr M142.QStringConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QStandardPaths_locateAll" locateAll' ::  HoppyFC.CInt -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr M144.QStringListConst)
foreign import ccall "genpop__QStandardPaths_locateAllWithOptions" locateAllWithOptions' ::  HoppyFC.CInt -> HoppyF.Ptr M142.QStringConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M144.QStringListConst)
foreign import ccall "genpop__QStandardPaths_setTestModeEnabled" setTestModeEnabled' ::  HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QStandardPaths_standardLocations" standardLocations' ::  HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M144.QStringListConst)
foreign import ccall "genpop__QStandardPaths_writableLocation" writableLocation' ::  HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)

class QStandardPathsValue a where
  withQStandardPathsPtr :: a -> (QStandardPathsConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QStandardPathsConstPtr a => QStandardPathsValue a where
  withQStandardPathsPtr = HoppyP.flip ($) . toQStandardPathsConst

class (HoppyFHR.CppPtr this) => QStandardPathsConstPtr this where
  toQStandardPathsConst :: this -> QStandardPathsConst

class (QStandardPathsConstPtr this) => QStandardPathsPtr this where
  toQStandardPaths :: this -> QStandardPaths

displayName :: (QStandardPathsStandardLocation) -> (HoppyP.IO QtahP.String)
displayName arg'1 =
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'1 >>= \arg'1' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (displayName' arg'1')

findExecutable :: (M142.QStringValue arg'1) => (arg'1) -> (HoppyP.IO QtahP.String)
findExecutable arg'1 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (findExecutable' arg'1')

findExecutableWithPaths :: (M142.QStringValue arg'1, M144.QStringListValue arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO QtahP.String)
findExecutableWithPaths arg'1 arg'2 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M144.withQStringListPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (findExecutableWithPaths' arg'1' arg'2')

locate :: (M142.QStringValue arg'2) => (QStandardPathsStandardLocation) -> (arg'2) -> (HoppyP.IO QtahP.String)
locate arg'1 arg'2 =
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'1 >>= \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (locate' arg'1' arg'2')

locateWithOptions :: (M142.QStringValue arg'2, IsQStandardPathsLocateOptions arg'3) => (QStandardPathsStandardLocation) -> (arg'2) -> (arg'3) -> (HoppyP.IO QtahP.String)
locateWithOptions arg'1 arg'2 arg'3 =
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'1 >>= \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    QtahP.return . QtahFlags.flagsToNum . toQStandardPathsLocateOptions
  ) arg'3 >>= \arg'3' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (locateWithOptions' arg'1' arg'2' arg'3')

locateAll :: (M142.QStringValue arg'2) => (QStandardPathsStandardLocation) -> (arg'2) -> (HoppyP.IO [QtahP.String])
locateAll arg'1 arg'2 =
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'1 >>= \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (HoppyFHR.decodeAndDelete . M144.QStringListConst) =<<
  (locateAll' arg'1' arg'2')

locateAllWithOptions :: (M142.QStringValue arg'2, IsQStandardPathsLocateOptions arg'3) => (QStandardPathsStandardLocation) -> (arg'2) -> (arg'3) -> (HoppyP.IO [QtahP.String])
locateAllWithOptions arg'1 arg'2 arg'3 =
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'1 >>= \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    QtahP.return . QtahFlags.flagsToNum . toQStandardPathsLocateOptions
  ) arg'3 >>= \arg'3' ->
  (HoppyFHR.decodeAndDelete . M144.QStringListConst) =<<
  (locateAllWithOptions' arg'1' arg'2' arg'3')

setTestModeEnabled :: (HoppyP.Bool) -> (HoppyP.IO ())
setTestModeEnabled arg'1 =
  (
    \x -> HoppyP.return $ if x then 1 else 0
  ) arg'1 >>= \arg'1' ->
  (setTestModeEnabled' arg'1')

standardLocations :: (QStandardPathsStandardLocation) -> (HoppyP.IO [QtahP.String])
standardLocations arg'1 =
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'1 >>= \arg'1' ->
  (HoppyFHR.decodeAndDelete . M144.QStringListConst) =<<
  (standardLocations' arg'1')

writableLocation :: (QStandardPathsStandardLocation) -> (HoppyP.IO QtahP.String)
writableLocation arg'1 =
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'1 >>= \arg'1' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (writableLocation' arg'1')

data QStandardPathsConst =
    QStandardPathsConst (HoppyF.Ptr QStandardPathsConst)
  | QStandardPathsConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QStandardPathsConst)
  deriving (HoppyP.Show)

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

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

castQStandardPathsToConst :: QStandardPaths -> QStandardPathsConst
castQStandardPathsToConst (QStandardPaths ptr') = QStandardPathsConst $ HoppyF.castPtr ptr'
castQStandardPathsToConst (QStandardPathsGc fptr' ptr') = QStandardPathsConstGc fptr' $ HoppyF.castPtr ptr'

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

instance QStandardPathsConstPtr QStandardPathsConst where
  toQStandardPathsConst = HoppyP.id

data QStandardPaths =
    QStandardPaths (HoppyF.Ptr QStandardPaths)
  | QStandardPathsGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QStandardPaths)
  deriving (HoppyP.Show)

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

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

castQStandardPathsToNonconst :: QStandardPathsConst -> QStandardPaths
castQStandardPathsToNonconst (QStandardPathsConst ptr') = QStandardPaths $ HoppyF.castPtr ptr'
castQStandardPathsToNonconst (QStandardPathsConstGc fptr' ptr') = QStandardPathsGc fptr' $ HoppyF.castPtr ptr'

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

instance QStandardPathsConstPtr QStandardPaths where
  toQStandardPathsConst (QStandardPaths ptr') = QStandardPathsConst $ (HoppyF.castPtr :: HoppyF.Ptr QStandardPaths -> HoppyF.Ptr QStandardPathsConst) ptr'
  toQStandardPathsConst (QStandardPathsGc fptr' ptr') = QStandardPathsConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QStandardPaths -> HoppyF.Ptr QStandardPathsConst) ptr'

instance QStandardPathsPtr QStandardPaths where
  toQStandardPaths = HoppyP.id

class QStandardPathsSuper a where
  downToQStandardPaths :: a -> QStandardPaths


class QStandardPathsSuperConst a where
  downToQStandardPathsConst :: a -> QStandardPathsConst


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

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

data QStandardPathsLocateOption =
  LocateFile
  | LocateDirectory
  | UnknownQStandardPathsLocateOption (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QStandardPathsLocateOption where
  fromCppEnum LocateFile = 0
  fromCppEnum LocateDirectory = 1
  fromCppEnum (UnknownQStandardPathsLocateOption n) = n
  
  toCppEnum (0) = LocateFile
  toCppEnum (1) = LocateDirectory
  toCppEnum n = UnknownQStandardPathsLocateOption n

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

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

newtype QStandardPathsLocateOptions = QStandardPathsLocateOptions (HoppyFC.CInt) deriving (QtahP.Eq, QtahP.Ord, QtahP.Show)

instance QtahFlags.Flags (HoppyFC.CInt) QStandardPathsLocateOption QStandardPathsLocateOptions where
  enumToFlags = QStandardPathsLocateOptions . QtahFHR.fromCppEnum
  flagsToEnum (QStandardPathsLocateOptions x') = QtahFHR.toCppEnum x'

class IsQStandardPathsLocateOptions a where
  toQStandardPathsLocateOptions :: a -> QStandardPathsLocateOptions

instance IsQStandardPathsLocateOptions QStandardPathsLocateOptions where toQStandardPathsLocateOptions = QtahP.id
instance IsQStandardPathsLocateOptions QStandardPathsLocateOption where toQStandardPathsLocateOptions = QtahFlags.enumToFlags
instance IsQStandardPathsLocateOptions (HoppyFC.CInt) where toQStandardPathsLocateOptions = QtahFlags.numToFlags

locateDirectory :: QStandardPathsLocateOptions
locateDirectory = QStandardPathsLocateOptions (1)

locateFile :: QStandardPathsLocateOptions
locateFile = QStandardPathsLocateOptions (0)

instance QtahDB.Bits QStandardPathsLocateOptions where
  x .&. y = QtahFlags.numToFlags (QtahFlags.flagsToNum x .&. QtahFlags.flagsToNum y)
  x .|. y = QtahFlags.numToFlags (QtahFlags.flagsToNum x .|. QtahFlags.flagsToNum y)
  xor x y = QtahFlags.numToFlags $ QtahDB.xor (QtahFlags.flagsToNum x) (QtahFlags.flagsToNum y)
  complement x = QtahFlags.numToFlags $ QtahDB.complement $ QtahFlags.flagsToNum x
  shift x i = QtahFlags.numToFlags $ QtahDB.shift (QtahFlags.flagsToNum x) i
  rotate x i = QtahFlags.numToFlags $ QtahDB.rotate (QtahFlags.flagsToNum x) i
  bitSize x = case QtahDB.bitSizeMaybe x of
      QtahP.Just n -> n
      QtahP.Nothing -> QtahP.error "bitSize is undefined"
  bitSizeMaybe = QtahDB.bitSizeMaybe . QtahFlags.flagsToNum
  isSigned = QtahDB.isSigned . QtahFlags.flagsToNum
  testBit x i = QtahDB.testBit (QtahFlags.flagsToNum x) i
  bit = QtahFlags.numToFlags . QtahDB.bit
  popCount = QtahDB.popCount . QtahFlags.flagsToNum

data QStandardPathsStandardLocation =
  DesktopLocation
  | DocumentsLocation
  | FontsLocation
  | ApplicationsLocation
  | MusicLocation
  | MoviesLocation
  | PicturesLocation
  | TempLocation
  | HomeLocation
  | DataLocation
  | CacheLocation
  | GenericDataLocation
  | RuntimeLocation
  | ConfigLocation
  | DownloadLocation
  | GenericCacheLocation
  | GenericConfigLocation
  | AppDataLocation
  | AppConfigLocation
  | UnknownQStandardPathsStandardLocation (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QStandardPathsStandardLocation where
  fromCppEnum DesktopLocation = 0
  fromCppEnum DocumentsLocation = 1
  fromCppEnum FontsLocation = 2
  fromCppEnum ApplicationsLocation = 3
  fromCppEnum MusicLocation = 4
  fromCppEnum MoviesLocation = 5
  fromCppEnum PicturesLocation = 6
  fromCppEnum TempLocation = 7
  fromCppEnum HomeLocation = 8
  fromCppEnum DataLocation = 9
  fromCppEnum CacheLocation = 10
  fromCppEnum GenericDataLocation = 11
  fromCppEnum RuntimeLocation = 12
  fromCppEnum ConfigLocation = 13
  fromCppEnum DownloadLocation = 14
  fromCppEnum GenericCacheLocation = 15
  fromCppEnum GenericConfigLocation = 16
  fromCppEnum AppDataLocation = 17
  fromCppEnum AppConfigLocation = 18
  fromCppEnum (UnknownQStandardPathsStandardLocation n) = n
  
  toCppEnum (0) = DesktopLocation
  toCppEnum (1) = DocumentsLocation
  toCppEnum (2) = FontsLocation
  toCppEnum (3) = ApplicationsLocation
  toCppEnum (4) = MusicLocation
  toCppEnum (5) = MoviesLocation
  toCppEnum (6) = PicturesLocation
  toCppEnum (7) = TempLocation
  toCppEnum (8) = HomeLocation
  toCppEnum (9) = DataLocation
  toCppEnum (10) = CacheLocation
  toCppEnum (11) = GenericDataLocation
  toCppEnum (12) = RuntimeLocation
  toCppEnum (13) = ConfigLocation
  toCppEnum (14) = DownloadLocation
  toCppEnum (15) = GenericCacheLocation
  toCppEnum (16) = GenericConfigLocation
  toCppEnum (17) = AppDataLocation
  toCppEnum (18) = AppConfigLocation
  toCppEnum n = UnknownQStandardPathsStandardLocation n

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

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