QFileSystemWatcher.hs

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

module Graphics.UI.Qtah.Generated.Core.QFileSystemWatcher (
  castQFileSystemWatcherToQObject,
  castQObjectToQFileSystemWatcher,
  QFileSystemWatcherValue (..),
  QFileSystemWatcherConstPtr (..),
  directories,
  files,
  QFileSystemWatcherPtr (..),
  addPath,
  addPaths,
  removePath,
  removePaths,
  QFileSystemWatcherConst (..),
  castQFileSystemWatcherToConst,
  QFileSystemWatcher (..),
  castQFileSystemWatcherToNonconst,
  new,
  newWithParent,
  newWithPaths,
  newWithPathsAndParent,
  QFileSystemWatcherSuper (..),
  QFileSystemWatcherSuperConst (..),
  ) 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 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__QFileSystemWatcher_new" new' ::  HoppyP.IO (HoppyF.Ptr QFileSystemWatcher)
foreign import ccall "genpop__QFileSystemWatcher_newWithParent" newWithParent' ::  HoppyF.Ptr M94.QObject -> HoppyP.IO (HoppyF.Ptr QFileSystemWatcher)
foreign import ccall "genpop__QFileSystemWatcher_newWithPaths" newWithPaths' ::  HoppyF.Ptr M144.QStringListConst -> HoppyP.IO (HoppyF.Ptr QFileSystemWatcher)
foreign import ccall "genpop__QFileSystemWatcher_newWithPathsAndParent" newWithPathsAndParent' ::  HoppyF.Ptr M144.QStringListConst -> HoppyF.Ptr M94.QObject -> HoppyP.IO (HoppyF.Ptr QFileSystemWatcher)
foreign import ccall "genpop__QFileSystemWatcher_addPath" addPath' ::  HoppyF.Ptr QFileSystemWatcher -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QFileSystemWatcher_addPaths" addPaths' ::  HoppyF.Ptr QFileSystemWatcher -> HoppyF.Ptr M144.QStringListConst -> HoppyP.IO (HoppyF.Ptr M144.QStringListConst)
foreign import ccall "genpop__QFileSystemWatcher_directories" directories' ::  HoppyF.Ptr QFileSystemWatcherConst -> HoppyP.IO (HoppyF.Ptr M144.QStringListConst)
foreign import ccall "genpop__QFileSystemWatcher_files" files' ::  HoppyF.Ptr QFileSystemWatcherConst -> HoppyP.IO (HoppyF.Ptr M144.QStringListConst)
foreign import ccall "genpop__QFileSystemWatcher_removePath" removePath' ::  HoppyF.Ptr QFileSystemWatcher -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QFileSystemWatcher_removePaths" removePaths' ::  HoppyF.Ptr QFileSystemWatcher -> HoppyF.Ptr M144.QStringListConst -> HoppyP.IO (HoppyF.Ptr M144.QStringListConst)
foreign import ccall "gencast__QFileSystemWatcher__QObject" castQFileSystemWatcherToQObject :: HoppyF.Ptr QFileSystemWatcherConst -> HoppyF.Ptr M94.QObjectConst
foreign import ccall "gencast__QObject__QFileSystemWatcher" castQObjectToQFileSystemWatcher :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr QFileSystemWatcherConst
foreign import ccall "gendel__QFileSystemWatcher" delete'QFileSystemWatcher :: HoppyF.Ptr QFileSystemWatcherConst -> HoppyP.IO ()
foreign import ccall "&gendel__QFileSystemWatcher" deletePtr'QFileSystemWatcher :: HoppyF.FunPtr (HoppyF.Ptr QFileSystemWatcherConst -> HoppyP.IO ())

class QFileSystemWatcherValue a where
  withQFileSystemWatcherPtr :: a -> (QFileSystemWatcherConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QFileSystemWatcherConstPtr a => QFileSystemWatcherValue a where
  withQFileSystemWatcherPtr = HoppyP.flip ($) . toQFileSystemWatcherConst

class (M94.QObjectConstPtr this) => QFileSystemWatcherConstPtr this where
  toQFileSystemWatcherConst :: this -> QFileSystemWatcherConst

directories :: (QFileSystemWatcherValue this) => (this) {- ^ this -} -> (HoppyP.IO [QtahP.String])
directories arg'1 =
  withQFileSystemWatcherPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M144.QStringListConst) =<<
  (directories' arg'1')

files :: (QFileSystemWatcherValue this) => (this) {- ^ this -} -> (HoppyP.IO [QtahP.String])
files arg'1 =
  withQFileSystemWatcherPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M144.QStringListConst) =<<
  (files' arg'1')

class (QFileSystemWatcherConstPtr this, M94.QObjectPtr this) => QFileSystemWatcherPtr this where
  toQFileSystemWatcher :: this -> QFileSystemWatcher

addPath :: (QFileSystemWatcherPtr this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
addPath arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQFileSystemWatcher arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (addPath' arg'1' arg'2')

addPaths :: (QFileSystemWatcherPtr this, M144.QStringListValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO [QtahP.String])
addPaths arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQFileSystemWatcher arg'1) $ \arg'1' ->
  M144.withQStringListPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (HoppyFHR.decodeAndDelete . M144.QStringListConst) =<<
  (addPaths' arg'1' arg'2')

removePath :: (QFileSystemWatcherPtr this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
removePath arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQFileSystemWatcher arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (removePath' arg'1' arg'2')

removePaths :: (QFileSystemWatcherPtr this, M144.QStringListValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO [QtahP.String])
removePaths arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQFileSystemWatcher arg'1) $ \arg'1' ->
  M144.withQStringListPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (HoppyFHR.decodeAndDelete . M144.QStringListConst) =<<
  (removePaths' arg'1' arg'2')

data QFileSystemWatcherConst =
    QFileSystemWatcherConst (HoppyF.Ptr QFileSystemWatcherConst)
  | QFileSystemWatcherConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QFileSystemWatcherConst)
  deriving (HoppyP.Show)

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

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

castQFileSystemWatcherToConst :: QFileSystemWatcher -> QFileSystemWatcherConst
castQFileSystemWatcherToConst (QFileSystemWatcher ptr') = QFileSystemWatcherConst $ HoppyF.castPtr ptr'
castQFileSystemWatcherToConst (QFileSystemWatcherGc fptr' ptr') = QFileSystemWatcherConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QFileSystemWatcherConstPtr QFileSystemWatcherConst where
  toQFileSystemWatcherConst = HoppyP.id

instance M94.QObjectConstPtr QFileSystemWatcherConst where
  toQObjectConst (QFileSystemWatcherConst ptr') = M94.QObjectConst $ castQFileSystemWatcherToQObject ptr'
  toQObjectConst (QFileSystemWatcherConstGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQFileSystemWatcherToQObject ptr'

data QFileSystemWatcher =
    QFileSystemWatcher (HoppyF.Ptr QFileSystemWatcher)
  | QFileSystemWatcherGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QFileSystemWatcher)
  deriving (HoppyP.Show)

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

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

castQFileSystemWatcherToNonconst :: QFileSystemWatcherConst -> QFileSystemWatcher
castQFileSystemWatcherToNonconst (QFileSystemWatcherConst ptr') = QFileSystemWatcher $ HoppyF.castPtr ptr'
castQFileSystemWatcherToNonconst (QFileSystemWatcherConstGc fptr' ptr') = QFileSystemWatcherGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QFileSystemWatcherConstPtr QFileSystemWatcher where
  toQFileSystemWatcherConst (QFileSystemWatcher ptr') = QFileSystemWatcherConst $ (HoppyF.castPtr :: HoppyF.Ptr QFileSystemWatcher -> HoppyF.Ptr QFileSystemWatcherConst) ptr'
  toQFileSystemWatcherConst (QFileSystemWatcherGc fptr' ptr') = QFileSystemWatcherConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QFileSystemWatcher -> HoppyF.Ptr QFileSystemWatcherConst) ptr'

instance QFileSystemWatcherPtr QFileSystemWatcher where
  toQFileSystemWatcher = HoppyP.id

instance M94.QObjectConstPtr QFileSystemWatcher where
  toQObjectConst (QFileSystemWatcher ptr') = M94.QObjectConst $ castQFileSystemWatcherToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QFileSystemWatcher -> HoppyF.Ptr QFileSystemWatcherConst) ptr'
  toQObjectConst (QFileSystemWatcherGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQFileSystemWatcherToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QFileSystemWatcher -> HoppyF.Ptr QFileSystemWatcherConst) ptr'

instance M94.QObjectPtr QFileSystemWatcher where
  toQObject (QFileSystemWatcher ptr') = M94.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQFileSystemWatcherToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QFileSystemWatcher -> HoppyF.Ptr QFileSystemWatcherConst) ptr'
  toQObject (QFileSystemWatcherGc fptr' ptr') = M94.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQFileSystemWatcherToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QFileSystemWatcher -> HoppyF.Ptr QFileSystemWatcherConst) ptr'

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

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

newWithPaths :: (M144.QStringListValue arg'1) => (arg'1) -> (HoppyP.IO QFileSystemWatcher)
newWithPaths arg'1 =
  M144.withQStringListPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QFileSystemWatcher
  (newWithPaths' arg'1')

newWithPathsAndParent :: (M144.QStringListValue arg'1, M94.QObjectPtr arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO QFileSystemWatcher)
newWithPathsAndParent arg'1 arg'2 =
  M144.withQStringListPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyFHR.withCppPtr (M94.toQObject arg'2) $ \arg'2' ->
  HoppyP.fmap QFileSystemWatcher
  (newWithPathsAndParent' arg'1' arg'2')

class QFileSystemWatcherSuper a where
  downToQFileSystemWatcher :: a -> QFileSystemWatcher

instance QFileSystemWatcherSuper M94.QObject where
  downToQFileSystemWatcher = castQFileSystemWatcherToNonconst . cast' . M94.castQObjectToConst
    where
      cast' (M94.QObjectConst ptr') = QFileSystemWatcherConst $ castQObjectToQFileSystemWatcher ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QFileSystemWatcherConstGc fptr' $ castQObjectToQFileSystemWatcher ptr'

class QFileSystemWatcherSuperConst a where
  downToQFileSystemWatcherConst :: a -> QFileSystemWatcherConst

instance QFileSystemWatcherSuperConst M94.QObjectConst where
  downToQFileSystemWatcherConst = cast'
    where
      cast' (M94.QObjectConst ptr') = QFileSystemWatcherConst $ castQObjectToQFileSystemWatcher ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QFileSystemWatcherConstGc fptr' $ castQObjectToQFileSystemWatcher ptr'

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

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